Merge branch 'master' of ssh://jra@git.samba.org/data/git/samba

diff --git a/.gitignore b/.gitignore
index 43f7846d1d3dcfe7b492ecc497615a488a4bb525..1d6420a1ab7ca545ef423c5790068290dfbec7fc 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -141,6 +141,7 @@ source4/dsdb/common/proto.h
 source4/dsdb/kcc/kcc_service_proto.h
 source4/dsdb/repl/drepl_service_proto.h
 source4/dsdb/samdb/samdb_proto.h
+source4/dsdb/samdb/ldb_modules/util_proto.h
 source4/dsdb/schema/proto.h
 source4/extra_cflags.txt
 source4/foo.tdb
@@ -264,6 +265,7 @@ pidl/Makefile
 pidl/pm_to_blib
 source4/rpc_server/common/proto.h
 source4/rpc_server/dcerpc_server_proto.h
+source4/rpc_server/service_rpc.h
 source4/rpc_server/lsa/proto.h
 source4/rpc_server/samr/proto.h
 source4/rpc_server/srvsvc/proto.h
@@ -296,6 +298,7 @@ source4/torture/proto.h
 source4/torture/rap/proto.h
 source4/torture/raw/proto.h
 source4/torture/rpc/proto.h
+source4/torture/drs/proto.h
 source4/torture/smb2/proto.h
 source4/torture.tdb
 source4/torture/unix/proto.h

diff --git a/client/mount.cifs.c b/client/mount.cifs.c
index 1c04e13c8d63aa30657d79f9a55d65d959e23af7..3baaad793713dbbe224348126cd57042f6d002f6 100644 (file)
--- a/client/mount.cifs.c
+++ b/client/mount.cifs.c
@@ -320,6 +320,11 @@ static int open_cred_file(char * file_name)
        char * temp_val;
        FILE * fs;
        int i, length;
+
+       i = access(file_name, R_OK);
+       if (i)
+               return i;
+
        fs = fopen(file_name,"r");
        if(fs == NULL)
                return errno;
@@ -442,6 +447,12 @@ static int get_password_from_file(int file_descript, char * filename)
        }
 
        if(filename != NULL) {
+               rc = access(filename, R_OK);
+               if (rc) {
+                       fprintf(stderr, "mount.cifs failed: access check of %s failed: %s\n",
+                                       filename, strerror(errno));
+                       exit(EX_SYSERR);
+               }
                file_descript = open(filename, O_RDONLY);
                if(file_descript < 0) {
                        fprintf(stderr, "mount.cifs failed. %s attempting to open password file %s\n",
@@ -501,9 +512,6 @@ static int parse_options(char ** optionsp, unsigned long * filesys_flags)
                return 1;
        data = *optionsp;
 
-       if(verboseflag)
-               fprintf(stderr, "parsing options: %s\n", data);
-
        /* BB fixme check for separator override BB */
 
        if (getuid()) {
@@ -594,14 +602,23 @@ static int parse_options(char ** optionsp, unsigned long * filesys_flags)
                                } else
                                        got_password = 1;
                        } else if (strnlen(value, MOUNT_PASSWD_SIZE) < MOUNT_PASSWD_SIZE) {
-                               if(got_password)
+                               if (got_password) {
                                        fprintf(stderr, "\nmount.cifs warning - password specified twice\n");
-                               got_password = 1;
+                               } else {
+                                       mountpassword = strndup(value, MOUNT_PASSWD_SIZE);
+                                       if (!mountpassword) {
+                                               fprintf(stderr, "mount.cifs error: %s", strerror(ENOMEM));
+                                               SAFE_FREE(out);
+                                               return 1;
+                                       }
+                                       got_password = 1;
+                               }
                        } else {
                                fprintf(stderr, "password too long\n");
                                SAFE_FREE(out);
                                return 1;
                        }
+                       goto nocopy;
                } else if (strncmp(data, "sec", 3) == 0) {
                        if (value) {
                                if (!strncmp(value, "none", 4) ||
@@ -1501,15 +1518,6 @@ mount_retry:
                        strlcat(options,domain_name,options_size);
                }
        }
-       if(mountpassword) {
-               /* Commas have to be doubled, or else they will
-               look like the parameter separator */
-/*             if(sep is not set)*/
-               if(retry == 0)
-                       check_for_comma(&mountpassword);
-               strlcat(options,",pass=",options_size);
-               strlcat(options,mountpassword,options_size);
-       }
 
        strlcat(options,",ver=",options_size);
        strlcat(options,MOUNT_CIFS_VERSION_MAJOR,options_size);
@@ -1522,8 +1530,6 @@ mount_retry:
                strlcat(options,",prefixpath=",options_size);
                strlcat(options,prefixpath,options_size); /* no need to cat the / */
        }
-       if(verboseflag)
-               fprintf(stderr, "\nmount.cifs kernel mount options %s \n",options);
 
        /* convert all '\\' to '/' in share portion so that /proc/mounts looks pretty */
        replace_char(dev_name, '\\', '/', strlen(share_name));
@@ -1565,6 +1571,25 @@ mount_retry:
                         addr6->sin6_scope_id);
        }
 
+       if(verboseflag)
+               fprintf(stderr, "\nmount.cifs kernel mount options: %s", options);
+
+       if (mountpassword) {
+               /*
+                * Commas have to be doubled, or else they will
+                * look like the parameter separator
+                */
+               if(retry == 0)
+                       check_for_comma(&mountpassword);
+               strlcat(options,",pass=",options_size);
+               strlcat(options,mountpassword,options_size);
+               if (verboseflag)
+                       fprintf(stderr, ",pass=********");
+       }
+
+       if (verboseflag)
+               fprintf(stderr, "\n");
+
        if (!fakemnt && mount(dev_name, mountpoint, "cifs", flags, options)) {
                switch (errno) {
                case ECONNREFUSED:

diff --git a/docs-xml/Samba3-HOWTO/TOSHARG-Winbind.xml b/docs-xml/Samba3-HOWTO/TOSHARG-Winbind.xml
index 33e2697bd3fac7f13c43f4fa24816bb2b495baae..b7eaa06b53923108238aed14ac50ce6f77d29077 100644 (file)
--- a/docs-xml/Samba3-HOWTO/TOSHARG-Winbind.xml
+++ b/docs-xml/Samba3-HOWTO/TOSHARG-Winbind.xml
@@ -93,7 +93,6 @@
 <indexterm><primary>idmap uid</primary></indexterm>
 <indexterm><primary>idmap gid</primary></indexterm>
 <indexterm><primary>idmap backend</primary></indexterm>
-<indexterm><primary>LDAP</primary></indexterm>
                Winbind maintains a database called winbind_idmap.tdb in which it stores
                mappings between UNIX UIDs, GIDs, and NT SIDs. This mapping is used only
                for users and groups that do not have a local UID/GID. It stores the UID/GID
@@ -210,7 +209,7 @@
        Users on the UNIX machine can then use NT user and group
        names as they would <quote>native</quote> UNIX names. They can chown files
        so they are owned by NT domain users or even login to the
-       UNIX machine and run a UNIX X-Window session as a domain user.</para>
+       UNIX machine and run a UNIX X Window session as a domain user.</para>
 
        <para>
 <indexterm><primary>domain controller</primary></indexterm>
@@ -571,7 +570,7 @@ is for you.
 <para>
 <indexterm><primary>PAM</primary></indexterm>
 <indexterm><primary>back up</primary></indexterm>
-<indexterm><primary>boot disk`</primary></indexterm>
+<indexterm><primary>boot disk</primary></indexterm>
 If you have a Samba configuration file that you are currently using, <emphasis>BACK IT UP!</emphasis>
 If your system already uses PAM, <emphasis>back up the <filename>/etc/pam.d</filename> directory
 contents!</emphasis> If you haven't already made a boot disk, <emphasis>MAKE ONE NOW!</emphasis>
@@ -602,8 +601,8 @@ instructions on downloading the source code.
 <indexterm><primary>development libraries</primary></indexterm>
 To allow domain users the ability to access Samba shares and files, as well as potentially other services
 provided by your Samba machine, PAM must be set up properly on your
-machine. In order to compile the Winbind modules, you should have at least the PAM development libraries installed
-on your system. Please refer to the PAM Web site <ulink url="http://www.kernel.org/pub/linux/libs/pam/"/>.
+machine. In order to compile the Winbind modules, the PAM development libraries should be installed
+on your system. Please refer to the <ulink url="http://www.kernel.org/pub/linux/libs/pam/">PAM Web Site</ulink>.
 </para>
 </sect2>
 
@@ -976,9 +975,6 @@ The same thing can be done for groups with the command:
 <indexterm><primary>/etc/init.d/smb</primary></indexterm>
 <indexterm><primary>/etc/init.d/samba</primary></indexterm>
 <indexterm><primary>/usr/local/samba/bin</primary></indexterm>
-<indexterm><primary></primary></indexterm>
-<indexterm><primary></primary></indexterm>
-<indexterm><primary></primary></indexterm>
 The &winbindd; daemon needs to start up after the &smbd; and &nmbd; daemons are running.  To accomplish this
 task, you need to modify the startup scripts of your system.  They are located at
 <filename>/etc/init.d/smb</filename> in Red Hat Linux and in <filename>/etc/init.d/samba</filename> in Debian
@@ -1119,7 +1115,7 @@ usually only starts smbd and nmbd but should now start winbindd, too. If you hav
 </programlisting></para>
 
 <para>
-Again, if you would like to run Samba in dual daemon mode, replace:
+Again, if you would like to run winbindd in dual daemon mode, replace:
 <programlisting>
 /usr/local/samba/sbin/winbindd
 </programlisting>
@@ -1234,7 +1230,7 @@ pre-create the directories of users to make sure users can log in on UNIX with t
 <indexterm><primary>Winbind</primary></indexterm>
 <indexterm><primary>ftp access</primary></indexterm>
 The <filename>/etc/pam.d/ftp</filename> file can be changed to allow Winbind ftp access in a manner similar to
-the samba file. My <filename>/etc/pam.d/ftp</filename> file was changed to look like this:
+the <filename>/etc/pam.d/samba</filename>Samba file. My <filename>/etc/pam.d/ftp</filename> file was changed to look like this:
 <programlisting>
 auth       required     /lib/security/pam_listfile.so item=user sense=deny \
         file=/etc/ftpusers onerr=succeed

diff --git a/docs-xml/manpages-3/ldbrename.1.xml b/docs-xml/manpages-3/ldbrename.1.xml
index 391ec84ccc3f56a6f4c05c4f613b29fc4bcc7f68..6a134f4268c5de52fa318547823b32a9cd6f14f8 100644 (file)
--- a/docs-xml/manpages-3/ldbrename.1.xml
+++ b/docs-xml/manpages-3/ldbrename.1.xml
@@ -5,6 +5,9 @@
 <refmeta>
        <refentrytitle>ldbrename</refentrytitle>
        <manvolnum>1</manvolnum>
+        <refmiscinfo class="source">Samba</refmiscinfo>
+        <refmiscinfo class="manual">User Commands</refmiscinfo>
+        <refmiscinfo class="version">3.6</refmiscinfo>
 </refmeta>
 
 

diff --git a/docs-xml/manpages-3/net.8.xml b/docs-xml/manpages-3/net.8.xml
index 82fd7a57af793b24089a1f5d360c1d4fb051955b..8ab33d58b06813d72ef5530348013f7afd4d6fee 100644 (file)
--- a/docs-xml/manpages-3/net.8.xml
+++ b/docs-xml/manpages-3/net.8.xml
@@ -748,6 +748,9 @@ such as domain name, domain sid and number of users and groups.
 <para>Add a interdomain trust account for <replaceable>DOMAIN</replaceable>. 
 This is in fact a Samba account named <replaceable>DOMAIN$</replaceable> 
 with the account flag <constant>'I'</constant> (interdomain trust account). 
+This is required for incoming trusts to work. It makes Samba be a
+trusted domain of the foreign (trusting) domain.
+Users of the Samba domain will be made available in the foreign domain.
 If the command is used against localhost it has the same effect as 
 <command>smbpasswd -a -i DOMAIN</command>. Please note that both commands
 expect a appropriate UNIX account. 
@@ -769,8 +772,13 @@ it has the same effect as <command>smbpasswd -x DOMAIN$</command>.
 <title>RPC TRUSTDOM ESTABLISH <replaceable>DOMAIN</replaceable></title>
 
 <para>
-Establish a trust relationship to a trusting domain. 
+Establish a trust relationship to a trusted domain. 
 Interdomain account must already be created on the remote PDC.
+This is required for outgoing trusts to work. It makes Samba be a
+trusting domain of a foreign (trusted) domain.
+Users of the foreign domain will be made available in our domain.
+You'll need winbind and a working idmap config to make them
+appear in your system.
 </para>
 
 </refsect3>
@@ -784,7 +792,7 @@ Interdomain account must already be created on the remote PDC.
 <refsect3>
 <title>RPC TRUSTDOM LIST</title>
 
-<para>List all current interdomain trust relationships.</para>
+<para>List all interdomain trust relationships.</para>
 
 </refsect3>
 
@@ -835,7 +843,7 @@ Force shutting down all applications.
 Timeout before system will be shut down. An interactive 
 user of the system can use this time to cancel the shutdown.
 </para></listitem>
-</varlistentry>'>
+</varlistentry>
 
 <varlistentry>
 <term>-C message</term>

diff --git a/docs-xml/manpages-3/wbinfo.1.xml b/docs-xml/manpages-3/wbinfo.1.xml
index 7803d1064f976974e475e06fc5664eec13cfcdb7..d6628e7da9efa63a360597f00a25d92196fbb1ea 100644 (file)
--- a/docs-xml/manpages-3/wbinfo.1.xml
+++ b/docs-xml/manpages-3/wbinfo.1.xml
@@ -23,6 +23,7 @@
                <arg choice="opt">--all-domains</arg>
                <arg choice="opt">--allocate-gid</arg>
                <arg choice="opt">--allocate-uid</arg>
+               <arg choice="opt">-c</arg>
                <arg choice="opt">-D domain</arg>
                <arg choice="opt">--domain domain</arg>
                <arg choice="opt">-g</arg>
@@ -110,6 +111,14 @@
                </para></listitem>
                </varlistentry>
 
+               <varlistentry>
+               <term>-c|--change-secret</term>
+               <listitem><para>Change the trust account password. May be used
+               in conjunction with <option>domain</option> in order to change
+               interdomain trust account passwords.
+               </para></listitem>
+               </varlistentry>
+
                <varlistentry>
                <term>--domain <replaceable>name</replaceable></term>
                <listitem><para>This parameter sets the domain on which any specified
@@ -283,7 +292,9 @@
                <term>-t|--check-secret</term>
                <listitem><para>Verify that the workstation trust account
                created when the Samba server is added to the Windows NT
-               domain is working. </para></listitem>
+               domain is working. May be used in conjunction with
+               <option>domain</option> in order to verify interdomain
+               trust accounts.</para></listitem>
                </varlistentry>
 
                <varlistentry>

diff --git a/docs-xml/smbdotconf/ldap/ldapreffollow.xml b/docs-xml/smbdotconf/ldap/ldapreffollow.xml
new file mode 100644 (file)
index 0000000..f059f15
--- /dev/null
+++ b/docs-xml/smbdotconf/ldap/ldapreffollow.xml
@@ -0,0 +1,21 @@
+<samba:parameter name="ldap ref follow" context="G" type="enum"
+       advanced="1" developer="1"
+       xmlns:samba="http://www.samba.org/samba/DTD/samba-doc">
+
+<description>
+
+       <para>This option controls whether to follow LDAP referrals or not when
+       searching for entries in the LDAP database. Possible values are
+       <emphasis>on</emphasis> to enable following referrals,
+       <emphasis>off</emphasis> to disable this, and
+       <emphasis>auto</emphasis>, to use the libldap default settings.
+       libldap's choice of following referrals or not is set in
+       /etc/openldap/ldap.conf with the REFERRALS parameter as documented in
+       ldap.conf(5).</para>
+
+</description>
+
+<value type="default">auto</value>
+<value type="example">off</value>
+
+</samba:parameter>

diff --git a/docs-xml/smbdotconf/protocol/sharefakefscaps.xml b/docs-xml/smbdotconf/protocol/sharefakefscaps.xml
new file mode 100644 (file)
index 0000000..713b95b
--- /dev/null
+++ b/docs-xml/smbdotconf/protocol/sharefakefscaps.xml
@@ -0,0 +1,20 @@
+<samba:parameter name="share:fake_fscaps"
+       context="G"
+       type="string"
+                advanced="1" developer="0"
+                 xmlns:samba="http://www.samba.org/samba/DTD/samba-doc">
+<description>
+
+       <para>
+       This is needed to support some special application that makes
+       QFSINFO calls to check whether we set the SPARSE_FILES bit
+       (0x40). If this bit is not set that particular application
+       refuses to work against
+       Samba. With <smbconfoption name="share:fake_fscaps">64</smbconfoption>
+       the SPARSE_FILES file system capability flag is set. Use other
+       decimal values to specify the bitmask you need to fake.
+       </para>
+
+</description>
+<value type="default">0</value>
+</samba:parameter>

diff --git a/docs-xml/smbdotconf/security/lanmanauth.xml b/docs-xml/smbdotconf/security/lanmanauth.xml
index 4e68c5e03aa16b5c5529343c475f7f75e2cf7911..e055bd35f1af8b3b5c56024aae964d1aac558fc4 100644 (file)
--- a/docs-xml/smbdotconf/security/lanmanauth.xml
+++ b/docs-xml/smbdotconf/security/lanmanauth.xml
@@ -16,6 +16,13 @@
     case-insensitive nature, and the choice of algorithm.  Servers
     without Windows 95/98/ME or MS DOS clients are advised to disable
     this option.  </para>
+
+    <para>When this parameter is set to <value>no</value> this
+    will also result in sambaLMPassword in Samba's passdb being
+    blanked after the next password change. As a result of that
+    lanman clients won't be able to authenticate, even if lanman
+    auth is reenabled later on.
+    </para>
                
     <para>Unlike the <command moreinfo="none">encrypt
     passwords</command> option, this parameter cannot alter client

diff --git a/examples/ad-bench/README b/examples/ad-bench/README
new file mode 100644 (file)
index 0000000..de6235f
--- /dev/null
+++ b/examples/ad-bench/README
@@ -0,0 +1,42 @@
+==========================
+Active Directory benchmark
+==========================
+
+Setup
+=====
+
+You need to modify settings.sh to point to the correct binaries for your
+platform. One thing you might want to do in order to be able to run the
+benchmark as a non-root user is to compile your own samba version with the
+--prefix configure option set to some location writeable by the user who will be
+running the benchmark. You then need to point the NET variable to the correct
+location.
+
+Most likely, you will also want to put the realm to kdc hostname mappings into
+krb5.conf and the hostname to IP address mappings for the kdcs to test into the
+hosts file, so you actually benchmark the AD speed, not DNS lookup speed.
+
+Running the benchmarks
+======================
+
+Per default, the benchmark looks for a file called runs.txt in the directory the
+benchmark is run from. (This is configurable in the settings.sh file)
+runs.txt contains the credentials and server names to connect to, one set of
+credentials/server per line. The format is as follows:
+
+user@REALM.EXAMPLE.COM%password:domain_controller_host_name
+
+License
+=======
+AD-Bench 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.
+
+AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.

diff --git a/examples/ad-bench/ad-bench.sh b/examples/ad-bench/ad-bench.sh
new file mode 100755 (executable)
index 0000000..84bb770
--- /dev/null
+++ b/examples/ad-bench/ad-bench.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+# AD-Bench main program, runs all the benchmarks
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+source `dirname $0`/utils.sh
+
+if [ ! -f $RUNS ]; then
+       echo "Error: please fill in $RUNS"
+       echo "Sambple entries are"
+       echo "user@REALM.EXAMPLE.COM%password:domain_controller"
+       exit 1
+fi
+
+for run in `cat $RUNS`; do
+       echo "START RUN"
+       bash `dirname $0`/time_kinit.sh `echo $run|cut -d ":" -f 1`
+       bash `dirname $0`/time_join.sh `echo $run|cut -d ":" -f 1` `echo $run|cut -d ":" -f 2`
+       bash `dirname $0`/time_user.sh `echo $run|cut -d ":" -f 1` `echo $run|cut -d ":" -f 2`
+       bash `dirname $0`/time_group.sh `echo $run|cut -d ":" -f 1` `echo $run|cut -d ":" -f 2`
+       bash `dirname $0`/time_ldap.sh `echo $run|cut -d ":" -f 1` `echo $run|cut -d ":" -f 2`
+       echo "END RUN"
+done

diff --git a/examples/ad-bench/settings.sh b/examples/ad-bench/settings.sh
new file mode 100644 (file)
index 0000000..f01edc3
--- /dev/null
+++ b/examples/ad-bench/settings.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+# AD-Bench settings
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+
+DATE=date
+BC=bc
+SED=sed
+DATE_FORMATSTR="+%s.%N"
+
+KINIT=kinit
+# MIT krb < 1.6
+KINIT_PARAM_OLD="--password-file=STDIN"
+# MIT krb >= 1.6
+KINIT_PARAM_NEW=""
+
+KDESTROY=kdestroy
+SEQ=seq
+
+NEW_KRB5CCNAME=/tmp/ad_test_ccname
+
+NET="${HOME}/samba/bin/net"
+CONFIG_FILE=`dirname $0`/smb.conf
+
+RUNS=`dirname $0`/runs.txt

diff --git a/examples/ad-bench/test_utils.sh b/examples/ad-bench/test_utils.sh
new file mode 100644 (file)
index 0000000..7f46b07
--- /dev/null
+++ b/examples/ad-bench/test_utils.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+# AD-Bench utility function tests
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+
+source `dirname $0`/utils.sh
+
+INPUT="administrator@AD.EXAMPLE.COM%secret"
+echo "Principal for $INPUT is " $( get_principal $INPUT )
+echo "Password  for $INPUT is " $( get_password $INPUT )
+echo "Realm     for $INPUT is " $( get_realm $INPUT )
+echo "NT_DOM    for $INPUT is " $( get_nt_dom $INPUT )
+
+
+echo "Padding 2: " $( pad_number 1 2 ) " 4: " $(pad_number 23 4)

diff --git a/examples/ad-bench/time_group.sh b/examples/ad-bench/time_group.sh
new file mode 100644 (file)
index 0000000..438376e
--- /dev/null
+++ b/examples/ad-bench/time_group.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# AD-Bench group add/remove benchmark
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+ITERATIONS=100
+
+source `dirname $0`/utils.sh
+
+PRINCIPAL=$(get_principal $1)
+PASSWORD=$(get_password $1)
+REALM=$(get_realm $1)
+NT_DOM=$(get_nt_dom $1)
+SERVER=$2
+
+add_group () {
+       GROUP=$1
+       ${NET} ads group add "${GROUP}" -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} ads group add returned error: $RET"
+               exit 1
+       fi
+}
+
+del_group () {
+       GROUP=$1
+       ${NET} ads group delete "${GROUP}" -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+enum_group () {
+       ${NET} ads group -k -s $CONFIG_FILE -S $SERVER > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+info_group () {
+       GROUP=$1
+       ${NET} ads group info "${GROUP}" -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+set_up () {
+       set_krb_env
+       setup_kinit
+       call_kinit "${PRINCIPAL}" "${PASSWORD}"
+       write_configfile "${REALM}" "${NT_DOM}"
+}
+
+tear_down () {
+       ${KDESTROY}
+       restore_krb_env
+}
+
+set_up
+
+echo -e "\tGROUP $SERVER"
+
+START_TIME=$(start_timer)
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       GROUP=$( echo "ad_test_$(pad_number $i 3)" )
+       add_group $GROUP
+       echo -n "."
+done
+echo "done"
+
+enum_group
+
+# Requires winbind, which requires root perms to start. Skip this for now
+#echo -en "\t"
+#for i in $( ${SEQ} 1 $ITERATIONS ); do
+#      GROUP=$( echo "ad_test_$(pad_number $i 3)" )
+#      info_group $GROUP
+#      echo -n "."
+#done
+#echo "done"
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       GROUP=$( echo "ad_test_$(pad_number $i 3)" )
+       del_group $GROUP
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$(stop_timer)
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+tear_down

diff --git a/examples/ad-bench/time_join.sh b/examples/ad-bench/time_join.sh
new file mode 100644 (file)
index 0000000..e9c3873
--- /dev/null
+++ b/examples/ad-bench/time_join.sh
@@ -0,0 +1,85 @@
+#!/bin/bash
+# AD-Bench Machine join/part benchmark
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+ITERATIONS=100
+
+source `dirname $0`/utils.sh
+
+PRINCIPAL=$(get_principal $1)
+PASSWORD=$(get_password $1)
+REALM=$(get_realm $1)
+NT_DOM=$(get_nt_dom $1)
+
+join_domain () {
+       SERVER=$1
+       ${NET} ads join -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+leave_domain () {
+       SERVER=$1
+       ${NET} ads leave -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+set_up () {
+       set_krb_env
+       setup_kinit
+       call_kinit "${PRINCIPAL}" "${PASSWORD}"
+       write_configfile "${REALM}" "${NT_DOM}"
+}
+
+tear_down () {
+       ${KDESTROY}
+       restore_krb_env
+}
+
+set_up
+
+echo -e "\tJOIN $2"
+
+START_TIME=$(start_timer)
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       join_domain $2
+       leave_domain $2
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$(stop_timer)
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+tear_down

diff --git a/examples/ad-bench/time_kinit.sh b/examples/ad-bench/time_kinit.sh
new file mode 100644 (file)
index 0000000..76c4ff4
--- /dev/null
+++ b/examples/ad-bench/time_kinit.sh
@@ -0,0 +1,63 @@
+#!/bin/bash
+# AD-Bench Kerberos ticket benchmark
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool.
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+# Iterations are set per test, so more time-consuming tests can be run less
+# often
+ITERATIONS=100
+
+source `dirname $0`/utils.sh
+
+set_up () {
+       set_krb_env
+       setup_kinit
+}
+
+tear_down () {
+       restore_krb_env
+}
+
+set_up
+
+PRINCIPAL=$( get_principal $1)
+PASSWORD=$( get_password $1)
+
+echo -e "\tKINIT ${PRINCIPAL}"
+
+START_TIME=$( start_timer )
+
+echo -en "\t"
+for i in $(${SEQ} 1 $ITERATIONS); do
+       call_kinit "${PRINCIPAL}" "${PASSWORD}"
+       ${KDESTROY}
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$( stop_timer )
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+tear_down

diff --git a/examples/ad-bench/time_ldap.sh b/examples/ad-bench/time_ldap.sh
new file mode 100644 (file)
index 0000000..586c568
--- /dev/null
+++ b/examples/ad-bench/time_ldap.sh
@@ -0,0 +1,137 @@
+#!/bin/bash
+
+ITERATIONS=100
+
+source `dirname $0`/utils.sh
+
+PRINCIPAL=$(get_principal $1)
+PASSWORD=$(get_password $1)
+REALM=$(get_realm $1)
+NT_DOM=$(get_nt_dom $1)
+SERVER=$2
+
+search_users () {
+       ${NET} ads search '(objectCategory=user)' sAMAccountName -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+search_groups () {
+       ${NET} ads search '(objectCategory=group)' sAMAccountName -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+search_computers () {
+       ${NET} ads search '(objectCategory=computer)' sAMAccountName -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+search_wildcard () {
+       ${NET} ads search '(objectCategory=*)' sAMAccountName -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+search_unindexed () {
+       ${NET} ads search '(description=Built-in account for adminstering the computer/domain)' sAMAccountName -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+set_up () {
+       set_krb_env
+       setup_kinit
+       call_kinit "${PRINCIPAL}" "${PASSWORD}"
+       write_configfile "${REALM}" "${NT_DOM}"
+}
+
+tear_down () {
+       ${KDESTROY}
+       restore_krb_env
+}
+
+set_up
+
+echo -e "\tSEARCH INDEXED $2"
+
+START_TIME=$(start_timer)
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       search_users
+       search_groups
+       search_computers
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$(stop_timer)
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+########################
+
+echo -e "\tSEARCH WILDCARD $2"
+
+START_TIME=$(start_timer)
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       search_wildcard
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$(stop_timer)
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+########################
+
+echo -e "\tSEARCH UNINDEXED $2"
+
+START_TIME=$(start_timer)
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       search_unindexed
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$(stop_timer)
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+tear_down

diff --git a/examples/ad-bench/time_user.sh b/examples/ad-bench/time_user.sh
new file mode 100644 (file)
index 0000000..5380115
--- /dev/null
+++ b/examples/ad-bench/time_user.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# AD-Bench user add/remove benchmark
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+ITERATIONS=100
+
+source `dirname $0`/utils.sh
+
+PRINCIPAL=$(get_principal $1)
+PASSWORD=$(get_password $1)
+REALM=$(get_realm $1)
+NT_DOM=$(get_nt_dom $1)
+SERVER=$2
+
+add_user () {
+       USER=$1
+       ${NET} ads user add "${USER}" 'Sup3rS3cr3T!' -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} ads user add returned error: $RET"
+               exit 1
+       fi
+}
+
+del_user () {
+       USER=$1
+       ${NET} ads user delete "${USER}" -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+enum_user () {
+       ${NET} ads user -k -s $CONFIG_FILE -S $SERVER > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+info_user () {
+       USER=$1
+       ${NET} ads user info "${USER}" -k -s $CONFIG_FILE -S ${SERVER} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "${NET} returned error: $RET"
+               exit 1
+       fi
+}
+
+set_up () {
+       set_krb_env
+       setup_kinit
+       call_kinit "${PRINCIPAL}" "${PASSWORD}"
+       write_configfile "${REALM}" "${NT_DOM}"
+}
+
+tear_down () {
+       ${KDESTROY}
+       restore_krb_env
+}
+
+set_up
+
+echo -e "\tUSER $SERVER"
+
+START_TIME=$(start_timer)
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       USER=$( echo "ad_test_$(pad_number $i 3)" )
+       add_user $USER
+       echo -n "."
+done
+echo "done"
+
+enum_user
+
+# Requires winbind, which requires root perms to start. Skip this for now
+#echo -en "\t"
+#for i in $( ${SEQ} 1 $ITERATIONS ); do
+#      USER=$( echo "ad_test_$(pad_number $i 3)" )
+#      info_user $USER
+#      echo -n "."
+#done
+#echo "done"
+
+echo -en "\t"
+for i in $( ${SEQ} 1 $ITERATIONS ); do
+       USER=$( echo "ad_test_$(pad_number $i 3)" )
+       del_user $USER
+       echo -n "."
+done
+echo "done"
+
+STOP_TIME=$(stop_timer)
+
+TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+echo -e "\t\ttotal time:\t\t${TOTAL_TIME}s"
+
+LOGINS_PER_MINUTE=$(iterations_per_minute $START_TIME $STOP_TIME $ITERATIONS)
+
+echo -e "\t\titerations/min:\t\t$LOGINS_PER_MINUTE"
+
+tear_down

diff --git a/examples/ad-bench/utils.sh b/examples/ad-bench/utils.sh
new file mode 100644 (file)
index 0000000..89da09c
--- /dev/null
+++ b/examples/ad-bench/utils.sh
@@ -0,0 +1,116 @@
+#!/bin/bash
+# AD-Bench utility functions
+#
+# Copyright (C) 2009  Kai Blin  <kai@samba.org>
+#
+# This file is part of AD-Bench, an Active Directory benchmark tool
+#
+# AD-Bench 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.
+#
+# AD-Bench 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 AD-Bench.  If not, see <http://www.gnu.org/licenses/>.
+
+source `dirname $0`/settings.sh
+
+start_timer () {
+       START_TIME=$( ${DATE} ${DATE_FORMATSTR} )
+       echo "$START_TIME"
+}
+
+stop_timer () {
+       STOP_TIME=$( ${DATE} ${DATE_FORMATSTR} )
+       echo "$STOP_TIME"
+}
+
+total_time () {
+       START_TIME=$1
+       END_TIME=$2
+       TOTAL_TIME=$( echo "scale=9;$STOP_TIME - $START_TIME" | ${BC} )
+       echo "$TOTAL_TIME"
+}
+
+iterations_per_minute () {
+       START_TIME=$1
+       STOP_TIME=$2
+       TOTAL_RUNS=$3
+
+       TOTAL_TIME=$( total_time $START_TIME $STOP_TIME )
+
+       ITER_PER_MIN=$( echo "scale=2; 60 * $TOTAL_RUNS / $TOTAL_TIME" | ${BC} )
+       echo "$ITER_PER_MIN"
+}
+
+get_principal () {
+       PRINCIPAL=$( echo $1 | ${SED} -e "s/\(.*\)%.*/\1/" )
+       echo "$PRINCIPAL"
+}
+
+get_password () {
+       PASSWORD=$( echo $1 | ${SED} -e "s/.*%\(.*\)/\1/" )
+       echo "$PASSWORD"
+}
+
+get_realm () {
+       REALM=$( echo $1 | ${SED} -e "s/.*@\(.*\)%.*/\1/" )
+       echo "$REALM"
+}
+
+get_nt_dom () {
+       NT_DOM=$( echo $1 | ${SED} -e "s/.*@\([A-Z1-9-]*\)\..*/\1/" )
+       echo "$NT_DOM"
+}
+
+set_krb_env () {
+       OLD_KRB5CCNAME="${KRB5CCNAME}"
+       KRB5CCNAME="${NEW_KRB5CCNAME}"
+       export KRB5CCNAME
+}
+
+restore_krb_env () {
+       KRB5CCNAME="${OLD_KRB5CCNAME}"
+       export KRB5CCNAME
+}
+
+setup_kinit () {
+       ${KINIT} --invalid 2>&1 | grep -q "password-file"
+       if [ $? -eq 0 ]; then
+               KINIT="${KINIT} ${KINIT_PARAM_OLD}"
+       else
+               KINIT="${KINIT} ${KINIT_PARAM_NEW}"
+       fi
+}
+
+write_configfile () {
+       REALM=$1
+       NT_DOM=$2
+       echo -e "[global]" > $CONFIG_FILE
+       echo -e "\trealm = $REALM" >> $CONFIG_FILE
+       echo -e "\tworkgroup = $NT_DOM" >> $CONFIG_FILE
+       echo -e "\tsecurity = ADS" >> $CONFIG_FILE
+}
+
+call_kinit () {
+       PRINCIPAL=$1
+       PASSWORD=$2
+       echo "${PASSWORD}" | ${KINIT} ${PRINCIPAL} > /dev/null
+       RET=$?
+       if [ $RET -ne 0 ]; then
+               echo "kinit returned an error: $RET"
+               exit 1
+       fi
+}
+
+pad_number () {
+       NUMBER=$1
+       DIGITS=$2
+       PADDED_NO=$(printf "%0${DIGITS}d" $NUMBER)
+       echo $PADDED_NO
+}

diff --git a/examples/perfcounter/Makefile b/examples/perfcounter/Makefile
index 925e2ea0803beaee81a6350f8616faf0a69279d8..bb7022e26c15363c35786cdd5c972f12b9aed930 100644 (file)
--- a/examples/perfcounter/Makefile
+++ b/examples/perfcounter/Makefile
@@ -15,10 +15,10 @@
 # along with this program; if not, see <http://www.gnu.org/licenses/>.
 # 
 
-SAMBA_SRC_DIR=../../source
-TDB_SRC_DIR=$(SAMBA_SRC_DIR)/tdb
+SAMBA_SRC_DIR=../../source3
+TDB_SRC_DIR=$(SAMBA_SRC_DIR)/../lib/tdb
 
-CFLAGS = -g -I$(SAMBA_SRC_DIR)/include -I$(TDB_SRC_DIR)/include
+CFLAGS = -g -I$(SAMBA_SRC_DIR) -I$(SAMBA_SRC_DIR)/include -I$(TDB_SRC_DIR)/include -I../../
 CC = gcc
 
 PROGS = perfcount

diff --git a/examples/perfcounter/perf.h b/examples/perfcounter/perf.h
index 2c24d31260a3519a6799e063a9bddd6fffb99971..7f06b05027ffb616605cb8bd05d1dbebdc9b4bd8 100644 (file)
--- a/examples/perfcounter/perf.h
+++ b/examples/perfcounter/perf.h
@@ -36,8 +36,8 @@
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <limits.h>
-#include "tdb.h"
-#include <rpc_perfcount_defs.h>
+#include <tdb.h>
+#include "librpc/gen_ndr/perfcount.h"
 #include <sys/statfs.h>
 #include <sys/times.h>
 #include <sys/sysinfo.h>

diff --git a/lib/talloc/configure.ac b/lib/talloc/configure.ac
index a169f7972445577bc8cf1563b23b5db0ea8fbeb5..c1b1d2e4a1217cf80f6f55f280b7cba6f8b41829 100644 (file)
--- a/lib/talloc/configure.ac
+++ b/lib/talloc/configure.ac
@@ -1,5 +1,5 @@
 AC_PREREQ(2.50)
-AC_INIT(talloc, 2.0.0)
+AC_INIT(talloc, 2.0.1)
 AC_CONFIG_SRCDIR([talloc.c])
 AC_SUBST(datarootdir)
 AC_CONFIG_HEADER(config.h)

diff --git a/lib/talloc/script/abi_checks.sh b/lib/talloc/script/abi_checks.sh
index ba60ed003a95f9372fb7d667542f57945a80f90f..66c4e60e45cb9bdf869c2cfaf1c91daed8a19b97 100755 (executable)
--- a/lib/talloc/script/abi_checks.sh
+++ b/lib/talloc/script/abi_checks.sh
@@ -33,6 +33,7 @@ LANG=C; export LANG
 LC_ALL=C; export LC_ALL
 LC_COLLATE=C; export LC_COLLATE
 
+exit_status=0
 script=$0
 dir_name=$(dirname ${script})
 
@@ -58,34 +59,22 @@ signatures_file_check=${signatures_file}.check
 
 
 ${dir_name}/mksyms.sh awk ${exports_file_check} ${headers} 2>&1 > /dev/null
+cat ${headers} | ${dir_name}/mksigs.pl | sort| uniq > ${signatures_file_check} 2> /dev/null
 
-cat ${headers} | ${dir_name}/mksigs.pl > ${signatures_file_check} 2> /dev/null
-
-normalize_exports_file() {
-       filename=$1
-       cat ${filename} \
-       | sed -e 's/^[ \t]*//g' \
-       | sed -e 's/^$//g' \
-       | sed -e 's/^#.*$//g' \
-       | sort | uniq > ${filename}.sort
-}
-
-normalize_exports_file ${exports_file}
-normalize_exports_file ${exports_file_check}
-
-normalize_exports_file ${signatures_file}
-normalize_exports_file ${signatures_file_check}
-
-diff -u ${exports_file}.sort ${exports_file_check}.sort
+diff -u ${exports_file} ${exports_file_check}
 if test "x$?" != "x0" ; then
        echo "WARNING: possible ABI change detected in exports!"
+       let exit_status++
 else
        echo "exports check: OK"
 fi
 
-diff -u ${signatures_file}.sort ${signatures_file_check}.sort
+diff -u ${signatures_file} ${signatures_file_check}
 if test "x$?" != "x0" ; then
        echo "WARNING: possible ABI change detected in signatures!"
+       let exit_status++
 else
        echo "signatures check: OK"
 fi
+
+exit $exit_status

diff --git a/lib/talloc/script/mksyms.awk b/lib/talloc/script/mksyms.awk
index ca14da0f2177bf2005a3e5835d9e6679c813669f..8775faff3feea63784e541ea4128e05fcf7e3866 100644 (file)
--- a/lib/talloc/script/mksyms.awk
+++ b/lib/talloc/script/mksyms.awk
@@ -8,25 +8,12 @@
 #
 BEGIN {
        inheader=0;
-       current_file="";
-       print "#"
-       print "# This file is automatically generated with \"make symbols\". DO NOT EDIT "
-       print "#"
-       print "{"
-       print "\tglobal:"
 }
 
 END {
-       print""
-       print "\tlocal: *;"
-       print "};"
 }
 
 {
-       if (FILENAME!=current_file) {
-               print "\t\t# The following definitions come from",FILENAME
-               current_file=FILENAME
-       }
        if (inheader) {
                if (match($0,"[)][^()]*[;][ \t]*$")) {
                        inheader = 0;
@@ -42,7 +29,7 @@ END {
 /^extern[ \t]+[^()]+[;][ \t]*$/ {
        gsub(/[^ \t]+[ \t]+/, "");
        sub(/[;][ \t]*$/, "");
-       printf "\t\t%s;\n", $0;
+       printf "           %s;\n", $0;
        next;
 }
 
@@ -61,7 +48,7 @@ END {
        sub(/[(].*$/, "");
        gsub(/[^ \t]+[ \t]+/, "");
        gsub(/^[*]+/, "");
-       printf "\t\t%s;\n",$0;
+       printf "           %s;\n",$0;
        next;
 }
 
@@ -70,7 +57,7 @@ END {
        sub(/[(].*$/, "");
        gsub(/[^ \t]+[ \t]+/, "");
        gsub(/^[*]/, "");
-       printf "\t\t%s;\n",$0;
+       printf "           %s;\n",$0;
        next;
 }
 

diff --git a/lib/talloc/script/mksyms.sh b/lib/talloc/script/mksyms.sh
index 714d55abae6a7369e1bb1da1f0d5cc5f7f29734d..089344f8f03a79736779181f4add12c70b42a556 100755 (executable)
--- a/lib/talloc/script/mksyms.sh
+++ b/lib/talloc/script/mksyms.sh
@@ -34,7 +34,24 @@ echo creating $symsfile
 
 mkdir -p `dirname $symsfile`
 
-${awk} -f `dirname $0`/mksyms.awk $proto_src > $symsfile_tmp
+#Write header
+cat > $symsfile_tmp << EOF
+# This file is autogenerated, please DO NOT EDIT
+{
+    global:
+EOF
+
+#loop on each header
+for i in $proto_src; do
+${awk} -f `dirname $0`/mksyms.awk $i | sort >> $symsfile_tmp
+done;
+
+#Write tail
+cat >> $symsfile_tmp << EOF
+
+    local: *;
+};
+EOF
 
 if cmp -s $symsfile $symsfile_tmp 2>/dev/null
 then

diff --git a/lib/talloc/release-script.sh b/lib/talloc/script/release-script.sh
similarity index 84%
rename from lib/talloc/release-script.sh
rename to lib/talloc/script/release-script.sh
index 6b6c0e7aad0a58aa30f0d4132c498c56b01fc377..4804f6ff58d749088ad27062955ffc4485d87cf5 100755 (executable)
--- a/lib/talloc/release-script.sh
+++ b/lib/talloc/script/release-script.sh
@@ -10,6 +10,16 @@ if [ ! -d "lib/talloc" ]; then
     exit 1
 fi
 
+# Check exports and signatures are up to date
+pushd lib/talloc
+./script/abi_checks.sh talloc talloc.h
+abicheck=$?
+popd
+if [ ! "$abicheck" = "0" ]; then
+    echo "ERROR: ABI Checks produced warnings!"
+    exit 1
+fi
+
 git clean -f -x -d lib/talloc
 git clean -f -x -d lib/replace
 

diff --git a/lib/talloc/talloc.exports b/lib/talloc/talloc.exports
index 75134c08029c93cdafe4e9eba3b94f8095f15dd3..1b8062f4a058cf73d710c210733498fda38040aa 100644 (file)
--- a/lib/talloc/talloc.exports
+++ b/lib/talloc/talloc.exports
@@ -1,7 +1,19 @@
+# This file is autogenerated, please DO NOT EDIT
 {
     global:
            _talloc;
            _talloc_array;
+           _talloc_free;
+           _talloc_get_type_abort;
+           _talloc_memdup;
+           _talloc_move;
+           _talloc_realloc;
+           _talloc_realloc_array;
+           _talloc_reference_loc;
+           _talloc_set_destructor;
+           _talloc_steal_loc;
+           _talloc_zero;
+           _talloc_zero_array;
            talloc_asprintf;
            talloc_asprintf_append;
            talloc_asprintf_append_buffer;
@@ -11,40 +23,32 @@
            talloc_enable_leak_report;
            talloc_enable_leak_report_full;
            talloc_enable_null_tracking;
+           talloc_enable_null_tracking_no_autofree;
            talloc_find_parent_byname;
-           _talloc_free;
            talloc_free_children;
            talloc_get_name;
            talloc_get_size;
-           _talloc_get_type_abort;
            talloc_increase_ref_count;
            talloc_init;
            talloc_is_parent;
-           _talloc_memdup;
-           _talloc_move;
            talloc_named;
            talloc_named_const;
            talloc_parent;
            talloc_parent_name;
            talloc_pool;
-           _talloc_realloc;
-           _talloc_realloc_array;
            talloc_realloc_fn;
            talloc_reference_count;
-           _talloc_reference_loc;
            talloc_reparent;
            talloc_report;
            talloc_report_depth_cb;
            talloc_report_depth_file;
            talloc_report_full;
            talloc_set_abort_fn;
-           _talloc_set_destructor;
            talloc_set_log_fn;
            talloc_set_log_stderr;
            talloc_set_name;
            talloc_set_name_const;
            talloc_show_parents;
-           _talloc_steal_loc;
            talloc_strdup;
            talloc_strdup_append;
            talloc_strdup_append_buffer;
@@ -59,8 +63,6 @@
            talloc_vasprintf_append_buffer;
            talloc_version_major;
            talloc_version_minor;
-           _talloc_zero;
-           _talloc_zero_array;
 
     local: *;
 };

diff --git a/lib/talloc/talloc.signatures b/lib/talloc/talloc.signatures
index 00fb4a3296800bfdf7798e06aee4e40052f34bb3..f2868e8269890744d10b073bbb508a430e4f947f 100644 (file)
--- a/lib/talloc/talloc.signatures
+++ b/lib/talloc/talloc.signatures
@@ -1,15 +1,15 @@
-char *talloc_asprintf_append_buffer (char *, const char *, ...);
-char *talloc_asprintf_append (char *, const char *, ...);
 char *talloc_asprintf (const void *, const char *, ...);
-char *talloc_strdup_append_buffer (char *, const char *);
-char *talloc_strdup_append (char *, const char *);
+char *talloc_asprintf_append (char *, const char *, ...);
+char *talloc_asprintf_append_buffer (char *, const char *, ...);
 char *talloc_strdup (const void *, const char *);
-char *talloc_strndup_append_buffer (char *, const char *, size_t);
-char *talloc_strndup_append (char *, const char *, size_t);
+char *talloc_strdup_append (char *, const char *);
+char *talloc_strdup_append_buffer (char *, const char *);
 char *talloc_strndup (const void *, const char *, size_t);
-char *talloc_vasprintf_append_buffer (char *, const char *, va_list);
-char *talloc_vasprintf_append (char *, const char *, va_list);
+char *talloc_strndup_append (char *, const char *, size_t);
+char *talloc_strndup_append_buffer (char *, const char *, size_t);
 char *talloc_vasprintf (const void *, const char *, va_list);
+char *talloc_vasprintf_append (char *, const char *, va_list);
+char *talloc_vasprintf_append_buffer (char *, const char *, va_list);
 const char *talloc_get_name (const void *);
 const char *talloc_parent_name (const void *);
 const char *talloc_set_name (const void *, const char *, ...);
@@ -23,39 +23,40 @@ size_t talloc_get_size (const void *);
 size_t talloc_reference_count (const void *);
 size_t talloc_total_blocks (const void *);
 size_t talloc_total_size (const void *);
+void *_talloc (const void *, size_t);
 void *_talloc_array (const void *, size_t, unsigned int, const char *);
+void *_talloc_get_type_abort (const void *, const char *, const char *);
+void *_talloc_memdup (const void *, const void *, size_t, const char *);
+void *_talloc_move (const void *, const void *);
+void *_talloc_realloc (const void *, void *, size_t, const char *);
+void *_talloc_realloc_array (const void *, void *, size_t, unsigned int, const char *);
+void *_talloc_reference_loc (const void *, const void *, const char *);
+void *_talloc_steal_loc (const void *, const void *, const char *);
+void *_talloc_zero (const void *, size_t, const char *);
+void *_talloc_zero_array (const void *, size_t, unsigned int, const char *);
 void *talloc_autofree_context (void);
 void *talloc_check_name (const void *, const char *);
-void *_talloc (const void *, size_t);
-void talloc_disable_null_tracking (void);
-void talloc_enable_leak_report_full (void);
-void talloc_enable_leak_report (void);
-void talloc_enable_null_tracking (void);
 void *talloc_find_parent_byname (const void *, const char *);
-void talloc_free_children (void *);
-void *_talloc_get_type_abort (const void *, const char *, const char *);
 void *talloc_init (const char *, ...);
-void *_talloc_memdup (const void *, const void *, size_t, const char *);
-void *_talloc_move (const void *, const void *);
-void *talloc_named_const (const void *, size_t, const char *);
 void *talloc_named (const void *, size_t, const char *, ...);
+void *talloc_named_const (const void *, size_t, const char *);
 void *talloc_parent (const void *);
 void *talloc_pool (const void *, size_t);
-void *_talloc_realloc_array (const void *, void *, size_t, unsigned int, const char *);
-void *_talloc_realloc (const void *, void *, size_t, const char *);
 void *talloc_realloc_fn (const void *, void *, size_t);
-void *_talloc_reference_loc (const void *, const void *, const char *);
 void *talloc_reparent (const void *, const void *, const void *);
+void _talloc_set_destructor (const void *, int (*) (void *));
+void talloc_disable_null_tracking (void);
+void talloc_enable_leak_report (void);
+void talloc_enable_leak_report_full (void);
+void talloc_enable_null_tracking (void);
+void talloc_enable_null_tracking_no_autofree (void);
+void talloc_free_children (void *);
 void talloc_report (const void *, FILE *);
 void talloc_report_depth_cb (const void *, int, int, void (*) (const void *, int, int, int, void *), void *);
 void talloc_report_depth_file (const void *, int, int, FILE *);
 void talloc_report_full (const void *, FILE *);
 void talloc_set_abort_fn (void (*) (const char *));
-void _talloc_set_destructor (const void *, int (*) (void *));
 void talloc_set_log_fn (void (*) (const char *));
 void talloc_set_log_stderr (void);
 void talloc_set_name_const (const void *, const char *);
 void talloc_show_parents (const void *, FILE *);
-void *_talloc_steal_loc (const void *, const void *, const char *);
-void *_talloc_zero_array (const void *, size_t, unsigned int, const char *);
-void *_talloc_zero (const void *, size_t, const char *);

diff --git a/lib/tdr/tdr.c b/lib/tdr/tdr.c
index 293436ed5e3474a942a1ab53efadbe65892aec3e..ce67003f8bfdfae5a618ad20ea5fc17b858c5c13 100644 (file)
--- a/lib/tdr/tdr.c
+++ b/lib/tdr/tdr.c
@@ -92,6 +92,11 @@ NTSTATUS tdr_pull_uint16(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v)
        return NT_STATUS_OK;
 }
 
+NTSTATUS tdr_pull_uint1632(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v)
+{
+       return tdr_pull_uint16(tdr, ctx, v);
+}
+
 NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v)
 {
        TDR_PUSH_NEED_BYTES(tdr, 2);
@@ -100,6 +105,11 @@ NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v)
        return NT_STATUS_OK;
 }
 
+NTSTATUS tdr_push_uint1632(struct tdr_push *tdr, const uint16_t *v)
+{
+       return tdr_push_uint16(tdr, v);
+}
+
 NTSTATUS tdr_print_uint16(struct tdr_print *tdr, const char *name, uint16_t *v)
 {
        tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);

diff --git a/lib/tdr/tdr.h b/lib/tdr/tdr.h
index 1eedc580d54fda841406f6f6ada90534d59440fb..84f3e50c2ba89691aa38ff6f1ef46736facd0643 100644 (file)
--- a/lib/tdr/tdr.h
+++ b/lib/tdr/tdr.h
@@ -55,7 +55,7 @@ struct tdr_print {
                         } while (0)
 
 #define TDR_ALLOC(ctx, s, n) do { \
-                              (s) = talloc_array_size(ctx, sizeof(*(s)), n); \
+                              (s) = talloc_array_ptrtype(ctx, (s), n); \
                            if ((n) && !(s)) return NT_STATUS_NO_MEMORY; \
                            } while (0)
 

diff --git a/lib/tevent/tevent_signal.c b/lib/tevent/tevent_signal.c
index d3325b67ac06a4dced5c96307299bd352325d7ef..ab170a66cf75f38c5785e720e3c7ceff83419e79 100644 (file)
--- a/lib/tevent/tevent_signal.c
+++ b/lib/tevent/tevent_signal.c
@@ -92,7 +92,7 @@ static void tevent_common_signal_handler(int signum)
 
        /* Write to each unique event context. */
        for (sl = sig_state->sig_handlers[signum]; sl; sl = sl->next) {
-               if (sl->se->event_ctx != ev) {
+               if (sl->se->event_ctx && sl->se->event_ctx != ev) {
                        ev = sl->se->event_ctx;
                        /* doesn't matter if this pipe overflows */
                        res = write(ev->pipe_fds[1], &c, 1);

diff --git a/lib/util/asn1.c b/lib/util/asn1.c
index 70c2c57450cc1de869fab961de8ea55911e8c9e4..946f71359c049ba5fe4c64b11c3dc6734c3cbbca 100644 (file)
--- a/lib/util/asn1.c
+++ b/lib/util/asn1.c
@@ -214,7 +214,7 @@ bool asn1_write_BitString(struct asn1_data *data, const void *p, size_t length,
        return asn1_pop_tag(data);
 }
 
-bool ber_write_OID_String(DATA_BLOB *blob, const char *OID)
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID)
 {
        uint_t v, v2;
        const char *p = (const char *)OID;
@@ -230,7 +230,7 @@ bool ber_write_OID_String(DATA_BLOB *blob, const char *OID)
        p = newp + 1;
 
        /*the ber representation can't use more space then the string one */
-       *blob = data_blob(NULL, strlen(OID));
+       *blob = data_blob_talloc(mem_ctx, NULL, strlen(OID));
        if (!blob->data) return false;
 
        blob->data[0] = 40*v + v2;
@@ -258,6 +258,41 @@ bool ber_write_OID_String(DATA_BLOB *blob, const char *OID)
        return true;
 }
 
+/**
+ * Serialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid)
+{
+       TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+       char *oid = talloc_strdup(tmp_ctx, partial_oid);
+       char *p;
+
+       /* truncate partial part so ber_write_OID_String() works */
+       p = strchr(oid, ':');
+       if (p) {
+               *p = '\0';
+               p++;
+       }
+
+       if (!ber_write_OID_String(mem_ctx, blob, oid)) {
+               talloc_free(tmp_ctx);
+               return false;
+       }
+
+       /* Add partially endcoded subidentifier */
+       if (p) {
+               DATA_BLOB tmp_blob = strhex_to_data_blob(tmp_ctx, p);
+               data_blob_append(mem_ctx, blob, tmp_blob.data, tmp_blob.length);
+       }
+
+       talloc_free(tmp_ctx);
+
+       return true;
+}
+
 /* write an object ID to a ASN1 buffer */
 bool asn1_write_OID(struct asn1_data *data, const char *OID)
 {
@@ -265,7 +300,7 @@ bool asn1_write_OID(struct asn1_data *data, const char *OID)
 
        if (!asn1_push_tag(data, ASN1_OID)) return false;
 
-       if (!ber_write_OID_String(&blob, OID)) {
+       if (!ber_write_OID_String(NULL, &blob, OID)) {
                data->has_error = true;
                return false;
        }
@@ -543,8 +578,13 @@ int asn1_tag_remaining(struct asn1_data *data)
        return remaining;
 }
 
-/* read an object ID from a data blob */
-bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID)
+/**
+ * Internal implementation for reading binary OIDs
+ * Reading is done as far in the buffer as valid OID
+ * till buffer ends or not valid sub-identifier is found.
+ */
+static bool _ber_read_OID_String_impl(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                       const char **OID, size_t *bytes_eaten)
 {
        int i;
        uint8_t *b;
@@ -565,19 +605,63 @@ bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID)
                if ( ! (b[i] & 0x80)) {
                        tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  v);
                        v = 0;
+                       if (bytes_eaten)
+                               *bytes_eaten = i+1;
                }
                if (!tmp_oid) goto nomem;
        }
 
-       if (v != 0) {
-               talloc_free(tmp_oid);
+       *OID = tmp_oid;
+       return true;
+
+nomem:
+       return false;
+}
+
+/* read an object ID from a data blob */
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID)
+{
+       size_t bytes_eaten;
+
+       if (!_ber_read_OID_String_impl(mem_ctx, blob, OID, &bytes_eaten))
+               return false;
+
+       return (bytes_eaten == blob.length);
+}
+
+/**
+ * Deserialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **partial_oid)
+{
+       size_t bytes_left;
+       size_t bytes_eaten;
+       char *identifier = NULL;
+       char *tmp_oid = NULL;
+
+       if (!_ber_read_OID_String_impl(mem_ctx, blob, (const char **)&tmp_oid, &bytes_eaten))
                return false;
+
+       if (bytes_eaten < blob.length) {
+               bytes_left = blob.length - bytes_eaten;
+               identifier = hex_encode_talloc(mem_ctx, &blob.data[bytes_eaten], bytes_left);
+               if (!identifier)        goto nomem;
+
+               *partial_oid = talloc_asprintf_append_buffer(tmp_oid, ":0x%s", identifier);
+               if (!*partial_oid)      goto nomem;
+               TALLOC_FREE(identifier);
+       } else {
+               *partial_oid = tmp_oid;
        }
 
-       *OID = tmp_oid;
        return true;
 
-nomem: 
+nomem:
+       TALLOC_FREE(identifier);
+       TALLOC_FREE(tmp_oid);
        return false;
 }
 

diff --git a/lib/util/asn1.h b/lib/util/asn1.h
index 9abae50d64ef6c1e1c905076d647eaccaa4287b7..ded3244bed15ce0b77859111926ef82428940f85 100644 (file)
--- a/lib/util/asn1.h
+++ b/lib/util/asn1.h
@@ -61,7 +61,8 @@ bool asn1_pop_tag(struct asn1_data *data);
 bool asn1_write_implicit_Integer(struct asn1_data *data, int i);
 bool asn1_write_Integer(struct asn1_data *data, int i);
 bool asn1_write_BitString(struct asn1_data *data, const void *p, size_t length, uint8_t padding);
-bool ber_write_OID_String(DATA_BLOB *blob, const char *OID);
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID);
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid);
 bool asn1_write_OID(struct asn1_data *data, const char *OID);
 bool asn1_write_OctetString(struct asn1_data *data, const void *p, size_t length);
 bool asn1_write_LDAPString(struct asn1_data *data, const char *s);
@@ -83,6 +84,7 @@ bool asn1_start_tag(struct asn1_data *data, uint8_t tag);
 bool asn1_end_tag(struct asn1_data *data);
 int asn1_tag_remaining(struct asn1_data *data);
 bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID);
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **partial_oid);
 bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, const char **OID);
 bool asn1_check_OID(struct asn1_data *data, const char *OID);
 bool asn1_read_LDAPString(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **s);

diff --git a/lib/util/talloc_stack.h b/lib/util/talloc_stack.h
index bb22b8a0294aed21a94eb412ed143c18d88aebed..777671164d5039a4de46370d3a73fc821e7bbb5c 100644 (file)
--- a/lib/util/talloc_stack.h
+++ b/lib/util/talloc_stack.h
@@ -35,7 +35,7 @@
 #ifndef _TALLOC_STACK_H
 #define _TALLOC_STACK_H
 
-#include "../talloc/talloc.h"
+#include "talloc.h"
 
 /*
  * Create a new talloc stack frame.

diff --git a/lib/util/tests/asn1_tests.c b/lib/util/tests/asn1_tests.c
new file mode 100644 (file)
index 0000000..25c8222
--- /dev/null
+++ b/lib/util/tests/asn1_tests.c
@@ -0,0 +1,260 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   util_asn1 testing
+
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "torture/torture.h"
+#include "../asn1.h"
+
+struct oid_data {
+       const char *oid;        /* String OID */
+       const char *bin_oid;    /* Binary OID represented as string */
+};
+
+/* Data for successful OIDs conversions */
+struct oid_data oid_data_ok[] = {
+       {
+               .oid = "2.5.4.0",
+               .bin_oid = "550400"
+       },
+       {
+               .oid = "2.5.4.1",
+               .bin_oid = "550401"
+       },
+       {
+               .oid = "2.5.4.130",
+               .bin_oid = "55048102"
+       },
+       {
+               .oid = "2.5.130.4",
+               .bin_oid = "55810204"
+       },
+       {
+               .oid = "2.5.4.16387",
+               .bin_oid = "5504818003"
+       },
+       {
+               .oid = "2.5.16387.4",
+               .bin_oid = "5581800304"
+       },
+       {
+               .oid = "2.5.2097155.4",
+               .bin_oid = "558180800304"
+       },
+       {
+               .oid = "2.5.4.130.16387.2097155.268435459",
+               .bin_oid = "55048102818003818080038180808003"
+       },
+};
+
+/* Data for successful Partial OIDs conversions */
+struct oid_data partial_oid_data_ok[] = {
+       {
+               .oid = "2.5.4.130:0x81",
+               .bin_oid = "5504810281"
+       },
+       {
+               .oid = "2.5.4.16387:0x8180",
+               .bin_oid = "55048180038180"
+       },
+       {
+               .oid = "2.5.4.16387:0x81",
+               .bin_oid = "550481800381"
+       },
+       {
+               .oid = "2.5.2097155.4:0x818080",
+               .bin_oid = "558180800304818080"
+       },
+       {
+               .oid = "2.5.2097155.4:0x8180",
+               .bin_oid = "5581808003048180"
+       },
+       {
+               .oid = "2.5.2097155.4:0x81",
+               .bin_oid = "55818080030481"
+       },
+};
+
+
+/* Testing ber_write_OID_String() function */
+static bool test_ber_write_OID_String(struct torture_context *tctx)
+{
+       int i;
+       char *hex_str;
+       DATA_BLOB blob;
+       TALLOC_CTX *mem_ctx;
+       struct oid_data *data = oid_data_ok;
+
+       mem_ctx = talloc_new(tctx);
+
+       for (i = 0; i < ARRAY_SIZE(oid_data_ok); i++) {
+               torture_assert(tctx, ber_write_OID_String(mem_ctx, &blob, data[i].oid),
+                               "ber_write_OID_String failed");
+
+               hex_str = hex_encode_talloc(mem_ctx, blob.data, blob.length);
+               torture_assert(tctx, hex_str, "No memory!");
+
+               torture_assert(tctx, strequal(data[i].bin_oid, hex_str),
+                               talloc_asprintf(mem_ctx,
+                                               "Failed: oid=%s, bin_oid:%s",
+                                               data[i].oid, data[i].bin_oid));
+       }
+
+       talloc_free(mem_ctx);
+
+       return true;
+}
+
+/* Testing ber_read_OID_String() function */
+static bool test_ber_read_OID_String(struct torture_context *tctx)
+{
+       int i;
+       const char *oid;
+       DATA_BLOB oid_blob;
+       TALLOC_CTX *mem_ctx;
+       struct oid_data *data = oid_data_ok;
+
+       mem_ctx = talloc_new(tctx);
+
+       for (i = 0; i < ARRAY_SIZE(oid_data_ok); i++) {
+               oid_blob = strhex_to_data_blob(mem_ctx, data[i].bin_oid);
+
+               torture_assert(tctx, ber_read_OID_String(mem_ctx, oid_blob, &oid),
+                               "ber_read_OID_String failed");
+
+               torture_assert(tctx, strequal(data[i].oid, oid),
+                               talloc_asprintf(mem_ctx,
+                                               "Failed: oid=%s, bin_oid:%s",
+                                               data[i].oid, data[i].bin_oid));
+       }
+
+       talloc_free(mem_ctx);
+
+       return true;
+}
+
+/* Testing ber_write_partial_OID_String() function */
+static bool test_ber_write_partial_OID_String(struct torture_context *tctx)
+{
+       int i;
+       char *hex_str;
+       DATA_BLOB blob;
+       TALLOC_CTX *mem_ctx;
+       struct oid_data *data = oid_data_ok;
+
+       mem_ctx = talloc_new(tctx);
+
+       /* ber_write_partial_OID_String() should work with not partial OIDs also */
+       for (i = 0; i < ARRAY_SIZE(oid_data_ok); i++) {
+               torture_assert(tctx, ber_write_partial_OID_String(mem_ctx, &blob, data[i].oid),
+                               "ber_write_partial_OID_String failed");
+
+               hex_str = hex_encode_talloc(mem_ctx, blob.data, blob.length);
+               torture_assert(tctx, hex_str, "No memory!");
+
+               torture_assert(tctx, strequal(data[i].bin_oid, hex_str),
+                               talloc_asprintf(mem_ctx,
+                                               "Failed: oid=%s, bin_oid:%s",
+                                               data[i].oid, data[i].bin_oid));
+       }
+
+       /* ber_write_partial_OID_String() test with partial OIDs */
+       data = partial_oid_data_ok;
+       for (i = 0; i < ARRAY_SIZE(partial_oid_data_ok); i++) {
+               torture_assert(tctx, ber_write_partial_OID_String(mem_ctx, &blob, data[i].oid),
+                               "ber_write_partial_OID_String failed");
+
+               hex_str = hex_encode_talloc(mem_ctx, blob.data, blob.length);
+               torture_assert(tctx, hex_str, "No memory!");
+
+               torture_assert(tctx, strequal(data[i].bin_oid, hex_str),
+                               talloc_asprintf(mem_ctx,
+                                               "Failed: oid=%s, bin_oid:%s",
+                                               data[i].oid, data[i].bin_oid));
+       }
+
+       talloc_free(mem_ctx);
+
+       return true;
+}
+
+/* Testing ber_read_partial_OID_String() function */
+static bool test_ber_read_partial_OID_String(struct torture_context *tctx)
+{
+       int i;
+       const char *oid;
+       DATA_BLOB oid_blob;
+       TALLOC_CTX *mem_ctx;
+       struct oid_data *data = oid_data_ok;
+
+       mem_ctx = talloc_new(tctx);
+
+       /* ber_read_partial_OID_String() should work with not partial OIDs also */
+       for (i = 0; i < ARRAY_SIZE(oid_data_ok); i++) {
+               oid_blob = strhex_to_data_blob(mem_ctx, data[i].bin_oid);
+
+               torture_assert(tctx, ber_read_partial_OID_String(mem_ctx, oid_blob, &oid),
+                               "ber_read_partial_OID_String failed");
+
+               torture_assert(tctx, strequal(data[i].oid, oid),
+                               talloc_asprintf(mem_ctx,
+                                               "Failed: oid=%s, bin_oid:%s",
+                                               data[i].oid, data[i].bin_oid));
+       }
+
+       /* ber_read_partial_OID_String() test with partial OIDs */
+       data = partial_oid_data_ok;
+       for (i = 0; i < ARRAY_SIZE(partial_oid_data_ok); i++) {
+               oid_blob = strhex_to_data_blob(mem_ctx, data[i].bin_oid);
+
+               torture_assert(tctx, ber_read_partial_OID_String(mem_ctx, oid_blob, &oid),
+                               "ber_read_partial_OID_String failed");
+
+               torture_assert(tctx, strequal(data[i].oid, oid),
+                               talloc_asprintf(mem_ctx,
+                                               "Failed: oid=%s, bin_oid:%s",
+                                               data[i].oid, data[i].bin_oid));
+       }
+
+       talloc_free(mem_ctx);
+
+       return true;
+}
+
+
+/* LOCAL-ASN1 test suite creation */
+struct torture_suite *torture_local_util_asn1(TALLOC_CTX *mem_ctx)
+{
+       struct torture_suite *suite = torture_suite_create(mem_ctx, "ASN1");
+
+       torture_suite_add_simple_test(suite, "ber_write_OID_String",
+                                     test_ber_write_OID_String);
+
+       torture_suite_add_simple_test(suite, "ber_read_OID_String",
+                                     test_ber_read_OID_String);
+
+       torture_suite_add_simple_test(suite, "ber_write_partial_OID_String",
+                                     test_ber_write_partial_OID_String);
+
+       torture_suite_add_simple_test(suite, "ber_read_partial_OID_String",
+                                     test_ber_read_partial_OID_String);
+
+       return suite;
+}

diff --git a/lib/util/tests/data_blob.c b/lib/util/tests/data_blob.c
index 875e5fdef8ef12b6825c8a3bf0b4ae93622395db..f0b02b8d171969437a90c19b85da148ce0be66f0 100644 (file)
--- a/lib/util/tests/data_blob.c
+++ b/lib/util/tests/data_blob.c
@@ -78,7 +78,7 @@ static bool test_cmp(struct torture_context *tctx)
 static bool test_hex_string(struct torture_context *tctx)
 {
        DATA_BLOB a = data_blob_string_const("\xC\xA\xF\xE");
-       torture_assert_str_equal(tctx, data_blob_hex_string(tctx, &a), "0C0A0F0E", "hex string");
+       torture_assert_str_equal(tctx, data_blob_hex_string(tctx, &a), "0c0a0f0e", "hex string");
        return true;
 }
 

diff --git a/lib/util/util.c b/lib/util/util.c
index 2a809d3ccb021d077e99e0c8a08b475ba2eb6dee..fd0e6b8d799c717b0b704bdc95ac0f3b6dd4e84c 100644 (file)
--- a/lib/util/util.c
+++ b/lib/util/util.c
@@ -579,18 +579,18 @@ _PUBLIC_ _PURE_ size_t count_chars(const char *s, char c)
 **/
 _PUBLIC_ size_t strhex_to_str(char *p, size_t p_len, const char *strhex, size_t strhex_len)
 {
-       size_t i;
+       size_t i = 0;
        size_t num_chars = 0;
        uint8_t   lonybble, hinybble;
        const char     *hexchars = "0123456789ABCDEF";
        char           *p1 = NULL, *p2 = NULL;
 
-       for (i = 0; i < strhex_len && strhex[i] != 0; i++) {
-               if (strncasecmp(hexchars, "0x", 2) == 0) {
-                       i++; /* skip two chars */
-                       continue;
-               }
+       /* skip leading 0x prefix */
+       if (strncasecmp(strhex, "0x", 2) == 0) {
+               i += 2; /* skip two chars */
+       }
 
+       for (; i < strhex_len && strhex[i] != 0; i++) {
                if (!(p1 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
                        break;
 
@@ -804,8 +804,8 @@ static bool next_token_internal_talloc(TALLOC_CTX *ctx,
                                 const char *sep,
                                 bool ltrim)
 {
-       char *s;
-       char *saved_s;
+       const char *s;
+       const char *saved_s;
        char *pbuf;
        bool quoted;
        size_t len=1;
@@ -815,7 +815,7 @@ static bool next_token_internal_talloc(TALLOC_CTX *ctx,
                return(false);
        }
 
-       s = (char *)*ptr;
+       s = *ptr;
 
        /* default to simple separators */
        if (!sep) {

diff --git a/lib/util/util_tdb.c b/lib/util/util_tdb.c
index e107cbdc4abf7594e22cef7b96f23642d758da51..cda8dc75b20f85982d3b4a70e1614023ee10edbf 100644 (file)
--- a/lib/util/util_tdb.c
+++ b/lib/util/util_tdb.c
@@ -20,7 +20,7 @@
 */
 
 #include "includes.h"
-#include "../tdb/include/tdb.h"
+#include "tdb.h"
 #include "../lib/util/util_tdb.h"
 
 /* these are little tdb utility functions that are meant to make

diff --git a/libcli/auth/schannel_state_ldb.c b/libcli/auth/schannel_state_ldb.c
index 69d6bad22c2de123cacdcce15fa25ebd20e7cd51..62873a424b75a5f4db99947671e42801370aac9d 100644 (file)
--- a/libcli/auth/schannel_state_ldb.c
+++ b/libcli/auth/schannel_state_ldb.c
@@ -28,8 +28,7 @@
 #include "libcli/auth/libcli_auth.h"
 #include "auth/auth.h"
 #include "param/param.h"
-#include "auth/gensec/schannel_state.h"
-#include "../libcli/auth/schannel_state_proto.h"
+#include "../libcli/auth/schannel_state.h"
 
 static struct ldb_val *schannel_dom_sid_ldb_val(TALLOC_CTX *mem_ctx,
                                                struct dom_sid *sid)

diff --git a/libcli/util/doserr.c b/libcli/util/doserr.c
index 5e741384677e8cd477380687c3caf65642806217..958c617ac9669e9fd7c5fa0535cca47114286967 100644 (file)
--- a/libcli/util/doserr.c
+++ b/libcli/util/doserr.c
@@ -66,7 +66,7 @@ static const struct werror_code_struct dos_errs[] =
        { "WERR_BUF_TOO_SMALL", WERR_BUF_TOO_SMALL },
        { "WERR_JOB_NOT_FOUND", WERR_JOB_NOT_FOUND },
        { "WERR_DEST_NOT_FOUND", WERR_DEST_NOT_FOUND },
-       { "WERR_GROUP_NOT_FOUND", WERR_GROUP_NOT_FOUND },
+       { "WERR_GROUPNOTFOUND", WERR_GROUPNOTFOUND },
        { "WERR_USER_NOT_FOUND", WERR_USER_NOT_FOUND },
        { "WERR_NOT_LOCAL_DOMAIN", WERR_NOT_LOCAL_DOMAIN },
        { "WERR_DOMAIN_CONTROLLER_NOT_FOUND", WERR_DOMAIN_CONTROLLER_NOT_FOUND },
@@ -76,7 +76,7 @@ static const struct werror_code_struct dos_errs[] =
        { "WERR_SETUP_DOMAIN_CONTROLLER", WERR_SETUP_DOMAIN_CONTROLLER },
        { "WERR_DEVICE_NOT_AVAILABLE", WERR_DEVICE_NOT_AVAILABLE },
        { "WERR_DEFAULT_JOIN_REQUIRED", WERR_DEFAULT_JOIN_REQUIRED },
-       { "WERR_USER_EXISTS", WERR_USER_EXISTS },
+       { "WERR_USEREXISTS", WERR_USEREXISTS },
        { "WERR_REVISION_MISMATCH", WERR_REVISION_MISMATCH },
        { "WERR_NO_LOGON_SERVERS", WERR_NO_LOGON_SERVERS },
        { "WERR_NO_SUCH_LOGON_SESSION", WERR_NO_SUCH_LOGON_SESSION },
@@ -105,7 +105,7 @@ static const struct werror_code_struct dos_errs[] =
        { "WERR_INVALID_COMPUTERNAME", WERR_INVALID_COMPUTERNAME },
        { "WERR_INVALID_DOMAINNAME", WERR_INVALID_DOMAINNAME },
        { "WERR_MACHINE_LOCKED", WERR_MACHINE_LOCKED },
-       { "WERR_DC_NOT_FOUND", WERR_DC_NOT_FOUND },
+       { "WERR_DCNOTFOUND", WERR_DCNOTFOUND },
        { "WERR_NO_LOGON_SERVERS", WERR_NO_LOGON_SERVERS },
        { "WERR_NO_SUCH_LOGON_SESSION", WERR_NO_SUCH_LOGON_SESSION },
        { "WERR_NO_SUCH_PRIVILEGE", WERR_NO_SUCH_PRIVILEGE },
@@ -217,6 +217,2366 @@ static const struct werror_code_struct dos_errs[] =
        { "WERR_PASSWORD_RESTRICTION", WERR_PASSWORD_RESTRICTION },
        { "WERR_WRONG_PASSWORD", WERR_WRONG_PASSWORD },
        { "WERR_CLASS_NOT_REGISTERED", WERR_CLASS_NOT_REGISTERED },
+       /*****************************************************************************
+        Auto-generated Win32 error from:
+        http://msdn.microsoft.com/en-us/library/cc231199%28PROT.10%29.aspx
+        *****************************************************************************/
+       /* BEGIN GENERATED-WIN32-ERROR-CODES */
+       { "WERR_NERR_SUCCESS", WERR_NERR_SUCCESS },
+       { "WERR_INVALID_FUNCTION", WERR_INVALID_FUNCTION },
+       { "WERR_FILE_NOT_FOUND", WERR_FILE_NOT_FOUND },
+       { "WERR_PATH_NOT_FOUND", WERR_PATH_NOT_FOUND },
+       { "WERR_TOO_MANY_OPEN_FILES", WERR_TOO_MANY_OPEN_FILES },
+       { "WERR_INVALID_HANDLE", WERR_INVALID_HANDLE },
+       { "WERR_ARENA_TRASHED", WERR_ARENA_TRASHED },
+       { "WERR_NOT_ENOUGH_MEMORY", WERR_NOT_ENOUGH_MEMORY },
+       { "WERR_INVALID_BLOCK", WERR_INVALID_BLOCK },
+       { "WERR_BAD_ENVIRONMENT", WERR_BAD_ENVIRONMENT },
+       { "WERR_BAD_FORMAT", WERR_BAD_FORMAT },
+       { "WERR_INVALID_ACCESS", WERR_INVALID_ACCESS },
+       { "WERR_INVALID_DATA", WERR_INVALID_DATA },
+       { "WERR_OUTOFMEMORY", WERR_OUTOFMEMORY },
+       { "WERR_INVALID_DRIVE", WERR_INVALID_DRIVE },
+       { "WERR_CURRENT_DIRECTORY", WERR_CURRENT_DIRECTORY },
+       { "WERR_NOT_SAME_DEVICE", WERR_NOT_SAME_DEVICE },
+       { "WERR_NO_MORE_FILES", WERR_NO_MORE_FILES },
+       { "WERR_WRITE_PROTECT", WERR_WRITE_PROTECT },
+       { "WERR_BAD_UNIT", WERR_BAD_UNIT },
+       { "WERR_NOT_READY", WERR_NOT_READY },
+       { "WERR_BAD_COMMAND", WERR_BAD_COMMAND },
+       { "WERR_CRC", WERR_CRC },
+       { "WERR_BAD_LENGTH", WERR_BAD_LENGTH },
+       { "WERR_SEEK", WERR_SEEK },
+       { "WERR_NOT_DOS_DISK", WERR_NOT_DOS_DISK },
+       { "WERR_SECTOR_NOT_FOUND", WERR_SECTOR_NOT_FOUND },
+       { "WERR_OUT_OF_PAPER", WERR_OUT_OF_PAPER },
+       { "WERR_WRITE_FAULT", WERR_WRITE_FAULT },
+       { "WERR_READ_FAULT", WERR_READ_FAULT },
+       { "WERR_GEN_FAILURE", WERR_GEN_FAILURE },
+       { "WERR_SHARING_VIOLATION", WERR_SHARING_VIOLATION },
+       { "WERR_LOCK_VIOLATION", WERR_LOCK_VIOLATION },
+       { "WERR_WRONG_DISK", WERR_WRONG_DISK },
+       { "WERR_SHARING_BUFFER_EXCEEDED", WERR_SHARING_BUFFER_EXCEEDED },
+       { "WERR_HANDLE_EOF", WERR_HANDLE_EOF },
+       { "WERR_HANDLE_DISK_FULL", WERR_HANDLE_DISK_FULL },
+       { "WERR_REM_NOT_LIST", WERR_REM_NOT_LIST },
+       { "WERR_NETWORK_BUSY", WERR_NETWORK_BUSY },
+       { "WERR_DEV_NOT_EXIST", WERR_DEV_NOT_EXIST },
+       { "WERR_TOO_MANY_CMDS", WERR_TOO_MANY_CMDS },
+       { "WERR_ADAP_HDW_ERR", WERR_ADAP_HDW_ERR },
+       { "WERR_BAD_REM_ADAP", WERR_BAD_REM_ADAP },
+       { "WERR_PRINT_CANCELLED", WERR_PRINT_CANCELLED },
+       { "WERR_NETNAME_DELETED", WERR_NETNAME_DELETED },
+       { "WERR_NETWORK_ACCESS_DENIED", WERR_NETWORK_ACCESS_DENIED },
+       { "WERR_BAD_DEV_TYPE", WERR_BAD_DEV_TYPE },
+       { "WERR_BAD_NET_NAME", WERR_BAD_NET_NAME },
+       { "WERR_TOO_MANY_NAMES", WERR_TOO_MANY_NAMES },
+       { "WERR_TOO_MANY_SESS", WERR_TOO_MANY_SESS },
+       { "WERR_SHARING_PAUSED", WERR_SHARING_PAUSED },
+       { "WERR_REQ_NOT_ACCEP", WERR_REQ_NOT_ACCEP },
+       { "WERR_REDIR_PAUSED", WERR_REDIR_PAUSED },
+       { "WERR_CANNOT_MAKE", WERR_CANNOT_MAKE },
+       { "WERR_FAIL_I24", WERR_FAIL_I24 },
+       { "WERR_OUT_OF_STRUCTURES", WERR_OUT_OF_STRUCTURES },
+       { "WERR_ALREADY_ASSIGNED", WERR_ALREADY_ASSIGNED },
+       { "WERR_INVALID_PASSWORD", WERR_INVALID_PASSWORD },
+       { "WERR_INVALID_PARAMETER", WERR_INVALID_PARAMETER },
+       { "WERR_NET_WRITE_FAULT", WERR_NET_WRITE_FAULT },
+       { "WERR_NO_PROC_SLOTS", WERR_NO_PROC_SLOTS },
+       { "WERR_TOO_MANY_SEMAPHORES", WERR_TOO_MANY_SEMAPHORES },
+       { "WERR_EXCL_SEM_ALREADY_OWNED", WERR_EXCL_SEM_ALREADY_OWNED },
+       { "WERR_SEM_IS_SET", WERR_SEM_IS_SET },
+       { "WERR_TOO_MANY_SEM_REQUESTS", WERR_TOO_MANY_SEM_REQUESTS },
+       { "WERR_INVALID_AT_INTERRUPT_TIME", WERR_INVALID_AT_INTERRUPT_TIME },
+       { "WERR_SEM_OWNER_DIED", WERR_SEM_OWNER_DIED },
+       { "WERR_SEM_USER_LIMIT", WERR_SEM_USER_LIMIT },
+       { "WERR_DISK_CHANGE", WERR_DISK_CHANGE },
+       { "WERR_DRIVE_LOCKED", WERR_DRIVE_LOCKED },
+       { "WERR_BROKEN_PIPE", WERR_BROKEN_PIPE },
+       { "WERR_OPEN_FAILED", WERR_OPEN_FAILED },
+       { "WERR_BUFFER_OVERFLOW", WERR_BUFFER_OVERFLOW },
+       { "WERR_DISK_FULL", WERR_DISK_FULL },
+       { "WERR_NO_MORE_SEARCH_HANDLES", WERR_NO_MORE_SEARCH_HANDLES },
+       { "WERR_INVALID_TARGET_HANDLE", WERR_INVALID_TARGET_HANDLE },
+       { "WERR_INVALID_CATEGORY", WERR_INVALID_CATEGORY },
+       { "WERR_INVALID_VERIFY_SWITCH", WERR_INVALID_VERIFY_SWITCH },
+       { "WERR_BAD_DRIVER_LEVEL", WERR_BAD_DRIVER_LEVEL },
+       { "WERR_INVALID_LEVEL", WERR_INVALID_LEVEL },
+       { "WERR_NO_VOLUME_LABEL", WERR_NO_VOLUME_LABEL },
+       { "WERR_MOD_NOT_FOUND", WERR_MOD_NOT_FOUND },
+       { "WERR_PROC_NOT_FOUND", WERR_PROC_NOT_FOUND },
+       { "WERR_WAIT_NO_CHILDREN", WERR_WAIT_NO_CHILDREN },
+       { "WERR_CHILD_NOT_COMPLETE", WERR_CHILD_NOT_COMPLETE },
+       { "WERR_DIRECT_ACCESS_HANDLE", WERR_DIRECT_ACCESS_HANDLE },
+       { "WERR_NEGATIVE_SEEK", WERR_NEGATIVE_SEEK },
+       { "WERR_SEEK_ON_DEVICE", WERR_SEEK_ON_DEVICE },
+       { "WERR_NOT_SUBSTED", WERR_NOT_SUBSTED },
+       { "WERR_JOIN_TO_JOIN", WERR_JOIN_TO_JOIN },
+       { "WERR_SUBST_TO_SUBST", WERR_SUBST_TO_SUBST },
+       { "WERR_JOIN_TO_SUBST", WERR_JOIN_TO_SUBST },
+       { "WERR_SAME_DRIVE", WERR_SAME_DRIVE },
+       { "WERR_DIR_NOT_ROOT", WERR_DIR_NOT_ROOT },
+       { "WERR_DIR_NOT_EMPTY", WERR_DIR_NOT_EMPTY },
+       { "WERR_IS_SUBST_PATH", WERR_IS_SUBST_PATH },
+       { "WERR_IS_JOIN_PATH", WERR_IS_JOIN_PATH },
+       { "WERR_PATH_BUSY", WERR_PATH_BUSY },
+       { "WERR_IS_SUBST_TARGET", WERR_IS_SUBST_TARGET },
+       { "WERR_SYSTEM_TRACE", WERR_SYSTEM_TRACE },
+       { "WERR_INVALID_EVENT_COUNT", WERR_INVALID_EVENT_COUNT },
+       { "WERR_TOO_MANY_MUXWAITERS", WERR_TOO_MANY_MUXWAITERS },
+       { "WERR_INVALID_LIST_FORMAT", WERR_INVALID_LIST_FORMAT },
+       { "WERR_LABEL_TOO_LONG", WERR_LABEL_TOO_LONG },
+       { "WERR_TOO_MANY_TCBS", WERR_TOO_MANY_TCBS },
+       { "WERR_SIGNAL_REFUSED", WERR_SIGNAL_REFUSED },
+       { "WERR_DISCARDED", WERR_DISCARDED },
+       { "WERR_NOT_LOCKED", WERR_NOT_LOCKED },
+       { "WERR_BAD_THREADID_ADDR", WERR_BAD_THREADID_ADDR },
+       { "WERR_BAD_ARGUMENTS", WERR_BAD_ARGUMENTS },
+       { "WERR_BAD_PATHNAME", WERR_BAD_PATHNAME },
+       { "WERR_SIGNAL_PENDING", WERR_SIGNAL_PENDING },
+       { "WERR_MAX_THRDS_REACHED", WERR_MAX_THRDS_REACHED },
+       { "WERR_LOCK_FAILED", WERR_LOCK_FAILED },
+       { "WERR_BUSY", WERR_BUSY },
+       { "WERR_CANCEL_VIOLATION", WERR_CANCEL_VIOLATION },
+       { "WERR_ATOMIC_LOCKS_NOT_SUPPORTED", WERR_ATOMIC_LOCKS_NOT_SUPPORTED },
+       { "WERR_INVALID_SEGMENT_NUMBER", WERR_INVALID_SEGMENT_NUMBER },
+       { "WERR_INVALID_ORDINAL", WERR_INVALID_ORDINAL },
+       { "WERR_INVALID_FLAG_NUMBER", WERR_INVALID_FLAG_NUMBER },
+       { "WERR_SEM_NOT_FOUND", WERR_SEM_NOT_FOUND },
+       { "WERR_INVALID_STARTING_CODESEG", WERR_INVALID_STARTING_CODESEG },
+       { "WERR_INVALID_STACKSEG", WERR_INVALID_STACKSEG },
+       { "WERR_INVALID_MODULETYPE", WERR_INVALID_MODULETYPE },
+       { "WERR_INVALID_EXE_SIGNATURE", WERR_INVALID_EXE_SIGNATURE },
+       { "WERR_EXE_MARKED_INVALID", WERR_EXE_MARKED_INVALID },
+       { "WERR_BAD_EXE_FORMAT", WERR_BAD_EXE_FORMAT },
+       { "WERR_ITERATED_DATA_EXCEEDS_64K", WERR_ITERATED_DATA_EXCEEDS_64K },
+       { "WERR_INVALID_MINALLOCSIZE", WERR_INVALID_MINALLOCSIZE },
+       { "WERR_DYNLINK_FROM_INVALID_RING", WERR_DYNLINK_FROM_INVALID_RING },
+       { "WERR_IOPL_NOT_ENABLED", WERR_IOPL_NOT_ENABLED },
+       { "WERR_INVALID_SEGDPL", WERR_INVALID_SEGDPL },
+       { "WERR_AUTODATASEG_EXCEEDS_64K", WERR_AUTODATASEG_EXCEEDS_64K },
+       { "WERR_RING2SEG_MUST_BE_MOVABLE", WERR_RING2SEG_MUST_BE_MOVABLE },
+       { "WERR_RELOC_CHAIN_XEEDS_SEGLIM", WERR_RELOC_CHAIN_XEEDS_SEGLIM },
+       { "WERR_INFLOOP_IN_RELOC_CHAIN", WERR_INFLOOP_IN_RELOC_CHAIN },
+       { "WERR_ENVVAR_NOT_FOUND", WERR_ENVVAR_NOT_FOUND },
+       { "WERR_NO_SIGNAL_SENT", WERR_NO_SIGNAL_SENT },
+       { "WERR_FILENAME_EXCED_RANGE", WERR_FILENAME_EXCED_RANGE },
+       { "WERR_RING2_STACK_IN_USE", WERR_RING2_STACK_IN_USE },
+       { "WERR_META_EXPANSION_TOO_LONG", WERR_META_EXPANSION_TOO_LONG },
+       { "WERR_INVALID_SIGNAL_NUMBER", WERR_INVALID_SIGNAL_NUMBER },
+       { "WERR_THREAD_1_INACTIVE", WERR_THREAD_1_INACTIVE },
+       { "WERR_LOCKED", WERR_LOCKED },
+       { "WERR_TOO_MANY_MODULES", WERR_TOO_MANY_MODULES },
+       { "WERR_NESTING_NOT_ALLOWED", WERR_NESTING_NOT_ALLOWED },
+       { "WERR_EXE_MACHINE_TYPE_MISMATCH", WERR_EXE_MACHINE_TYPE_MISMATCH },
+       { "WERR_EXE_CANNOT_MODIFY_SIGNED_BINARY", WERR_EXE_CANNOT_MODIFY_SIGNED_BINARY },
+       { "WERR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY", WERR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY },
+       { "WERR_FILE_CHECKED_OUT", WERR_FILE_CHECKED_OUT },
+       { "WERR_CHECKOUT_REQUIRED", WERR_CHECKOUT_REQUIRED },
+       { "WERR_BAD_FILE_TYPE", WERR_BAD_FILE_TYPE },
+       { "WERR_FILE_TOO_LARGE", WERR_FILE_TOO_LARGE },
+       { "WERR_FORMS_AUTH_REQUIRED", WERR_FORMS_AUTH_REQUIRED },
+       { "WERR_VIRUS_INFECTED", WERR_VIRUS_INFECTED },
+       { "WERR_VIRUS_DELETED", WERR_VIRUS_DELETED },
+       { "WERR_PIPE_LOCAL", WERR_PIPE_LOCAL },
+       { "WERR_BAD_PIPE", WERR_BAD_PIPE },
+       { "WERR_PIPE_BUSY", WERR_PIPE_BUSY },
+       { "WERR_NO_DATA", WERR_NO_DATA },
+       { "WERR_PIPE_NOT_CONNECTED", WERR_PIPE_NOT_CONNECTED },
+       { "WERR_VC_DISCONNECTED", WERR_VC_DISCONNECTED },
+       { "WERR_INVALID_EA_NAME", WERR_INVALID_EA_NAME },
+       { "WERR_EA_LIST_INCONSISTENT", WERR_EA_LIST_INCONSISTENT },
+       { "WERR_WAIT_TIMEOUT", WERR_WAIT_TIMEOUT },
+       { "WERR_CANNOT_COPY", WERR_CANNOT_COPY },
+       { "WERR_DIRECTORY", WERR_DIRECTORY },
+       { "WERR_EAS_DIDNT_FIT", WERR_EAS_DIDNT_FIT },
+       { "WERR_EA_FILE_CORRUPT", WERR_EA_FILE_CORRUPT },
+       { "WERR_EA_TABLE_FULL", WERR_EA_TABLE_FULL },
+       { "WERR_INVALID_EA_HANDLE", WERR_INVALID_EA_HANDLE },
+       { "WERR_EAS_NOT_SUPPORTED", WERR_EAS_NOT_SUPPORTED },
+       { "WERR_NOT_OWNER", WERR_NOT_OWNER },
+       { "WERR_TOO_MANY_POSTS", WERR_TOO_MANY_POSTS },
+       { "WERR_PARTIAL_COPY", WERR_PARTIAL_COPY },
+       { "WERR_OPLOCK_NOT_GRANTED", WERR_OPLOCK_NOT_GRANTED },
+       { "WERR_INVALID_OPLOCK_PROTOCOL", WERR_INVALID_OPLOCK_PROTOCOL },
+       { "WERR_DISK_TOO_FRAGMENTED", WERR_DISK_TOO_FRAGMENTED },
+       { "WERR_DELETE_PENDING", WERR_DELETE_PENDING },
+       { "WERR_MR_MID_NOT_FOUND", WERR_MR_MID_NOT_FOUND },
+       { "WERR_SCOPE_NOT_FOUND", WERR_SCOPE_NOT_FOUND },
+       { "WERR_FAIL_NOACTION_REBOOT", WERR_FAIL_NOACTION_REBOOT },
+       { "WERR_FAIL_SHUTDOWN", WERR_FAIL_SHUTDOWN },
+       { "WERR_FAIL_RESTART", WERR_FAIL_RESTART },
+       { "WERR_MAX_SESSIONS_REACHED", WERR_MAX_SESSIONS_REACHED },
+       { "WERR_THREAD_MODE_ALREADY_BACKGROUND", WERR_THREAD_MODE_ALREADY_BACKGROUND },
+       { "WERR_THREAD_MODE_NOT_BACKGROUND", WERR_THREAD_MODE_NOT_BACKGROUND },
+       { "WERR_PROCESS_MODE_ALREADY_BACKGROUND", WERR_PROCESS_MODE_ALREADY_BACKGROUND },
+       { "WERR_PROCESS_MODE_NOT_BACKGROUND", WERR_PROCESS_MODE_NOT_BACKGROUND },
+       { "WERR_INVALID_ADDRESS", WERR_INVALID_ADDRESS },
+       { "WERR_USER_PROFILE_LOAD", WERR_USER_PROFILE_LOAD },
+       { "WERR_ARITHMETIC_OVERFLOW", WERR_ARITHMETIC_OVERFLOW },
+       { "WERR_PIPE_CONNECTED", WERR_PIPE_CONNECTED },
+       { "WERR_PIPE_LISTENING", WERR_PIPE_LISTENING },
+       { "WERR_VERIFIER_STOP", WERR_VERIFIER_STOP },
+       { "WERR_ABIOS_ERROR", WERR_ABIOS_ERROR },
+       { "WERR_WX86_WARNING", WERR_WX86_WARNING },
+       { "WERR_WX86_ERROR", WERR_WX86_ERROR },
+       { "WERR_TIMER_NOT_CANCELED", WERR_TIMER_NOT_CANCELED },
+       { "WERR_UNWIND", WERR_UNWIND },
+       { "WERR_BAD_STACK", WERR_BAD_STACK },
+       { "WERR_INVALID_UNWIND_TARGET", WERR_INVALID_UNWIND_TARGET },
+       { "WERR_INVALID_PORT_ATTRIBUTES", WERR_INVALID_PORT_ATTRIBUTES },
+       { "WERR_PORT_MESSAGE_TOO_LONG", WERR_PORT_MESSAGE_TOO_LONG },
+       { "WERR_INVALID_QUOTA_LOWER", WERR_INVALID_QUOTA_LOWER },
+       { "WERR_DEVICE_ALREADY_ATTACHED", WERR_DEVICE_ALREADY_ATTACHED },
+       { "WERR_INSTRUCTION_MISALIGNMENT", WERR_INSTRUCTION_MISALIGNMENT },
+       { "WERR_PROFILING_NOT_STARTED", WERR_PROFILING_NOT_STARTED },
+       { "WERR_PROFILING_NOT_STOPPED", WERR_PROFILING_NOT_STOPPED },
+       { "WERR_COULD_NOT_INTERPRET", WERR_COULD_NOT_INTERPRET },
+       { "WERR_PROFILING_AT_LIMIT", WERR_PROFILING_AT_LIMIT },
+       { "WERR_CANT_WAIT", WERR_CANT_WAIT },
+       { "WERR_CANT_TERMINATE_SELF", WERR_CANT_TERMINATE_SELF },
+       { "WERR_UNEXPECTED_MM_CREATE_ERR", WERR_UNEXPECTED_MM_CREATE_ERR },
+       { "WERR_UNEXPECTED_MM_MAP_ERROR", WERR_UNEXPECTED_MM_MAP_ERROR },
+       { "WERR_UNEXPECTED_MM_EXTEND_ERR", WERR_UNEXPECTED_MM_EXTEND_ERR },
+       { "WERR_BAD_FUNCTION_TABLE", WERR_BAD_FUNCTION_TABLE },
+       { "WERR_NO_GUID_TRANSLATION", WERR_NO_GUID_TRANSLATION },
+       { "WERR_INVALID_LDT_SIZE", WERR_INVALID_LDT_SIZE },
+       { "WERR_INVALID_LDT_OFFSET", WERR_INVALID_LDT_OFFSET },
+       { "WERR_INVALID_LDT_DESCRIPTOR", WERR_INVALID_LDT_DESCRIPTOR },
+       { "WERR_TOO_MANY_THREADS", WERR_TOO_MANY_THREADS },
+       { "WERR_THREAD_NOT_IN_PROCESS", WERR_THREAD_NOT_IN_PROCESS },
+       { "WERR_PAGEFILE_QUOTA_EXCEEDED", WERR_PAGEFILE_QUOTA_EXCEEDED },
+       { "WERR_LOGON_SERVER_CONFLICT", WERR_LOGON_SERVER_CONFLICT },
+       { "WERR_SYNCHRONIZATION_REQUIRED", WERR_SYNCHRONIZATION_REQUIRED },
+       { "WERR_NET_OPEN_FAILED", WERR_NET_OPEN_FAILED },
+       { "WERR_IO_PRIVILEGE_FAILED", WERR_IO_PRIVILEGE_FAILED },
+       { "WERR_CONTROL_C_EXIT", WERR_CONTROL_C_EXIT },
+       { "WERR_MISSING_SYSTEMFILE", WERR_MISSING_SYSTEMFILE },
+       { "WERR_UNHANDLED_EXCEPTION", WERR_UNHANDLED_EXCEPTION },
+       { "WERR_APP_INIT_FAILURE", WERR_APP_INIT_FAILURE },
+       { "WERR_PAGEFILE_CREATE_FAILED", WERR_PAGEFILE_CREATE_FAILED },
+       { "WERR_INVALID_IMAGE_HASH", WERR_INVALID_IMAGE_HASH },
+       { "WERR_NO_PAGEFILE", WERR_NO_PAGEFILE },
+       { "WERR_ILLEGAL_FLOAT_CONTEXT", WERR_ILLEGAL_FLOAT_CONTEXT },
+       { "WERR_NO_EVENT_PAIR", WERR_NO_EVENT_PAIR },
+       { "WERR_DOMAIN_CTRLR_CONFIG_ERROR", WERR_DOMAIN_CTRLR_CONFIG_ERROR },
+       { "WERR_ILLEGAL_CHARACTER", WERR_ILLEGAL_CHARACTER },
+       { "WERR_UNDEFINED_CHARACTER", WERR_UNDEFINED_CHARACTER },
+       { "WERR_FLOPPY_VOLUME", WERR_FLOPPY_VOLUME },
+       { "WERR_BIOS_FAILED_TO_CONNECT_INTERRUPT", WERR_BIOS_FAILED_TO_CONNECT_INTERRUPT },
+       { "WERR_BACKUP_CONTROLLER", WERR_BACKUP_CONTROLLER },
+       { "WERR_MUTANT_LIMIT_EXCEEDED", WERR_MUTANT_LIMIT_EXCEEDED },
+       { "WERR_FS_DRIVER_REQUIRED", WERR_FS_DRIVER_REQUIRED },
+       { "WERR_CANNOT_LOAD_REGISTRY_FILE", WERR_CANNOT_LOAD_REGISTRY_FILE },
+       { "WERR_DEBUG_ATTACH_FAILED", WERR_DEBUG_ATTACH_FAILED },
+       { "WERR_SYSTEM_PROCESS_TERMINATED", WERR_SYSTEM_PROCESS_TERMINATED },
+       { "WERR_DATA_NOT_ACCEPTED", WERR_DATA_NOT_ACCEPTED },
+       { "WERR_VDM_HARD_ERROR", WERR_VDM_HARD_ERROR },
+       { "WERR_DRIVER_CANCEL_TIMEOUT", WERR_DRIVER_CANCEL_TIMEOUT },
+       { "WERR_REPLY_MESSAGE_MISMATCH", WERR_REPLY_MESSAGE_MISMATCH },
+       { "WERR_LOST_WRITEBEHIND_DATA", WERR_LOST_WRITEBEHIND_DATA },
+       { "WERR_CLIENT_SERVER_PARAMETERS_INVALID", WERR_CLIENT_SERVER_PARAMETERS_INVALID },
+       { "WERR_NOT_TINY_STREAM", WERR_NOT_TINY_STREAM },
+       { "WERR_STACK_OVERFLOW_READ", WERR_STACK_OVERFLOW_READ },
+       { "WERR_CONVERT_TO_LARGE", WERR_CONVERT_TO_LARGE },
+       { "WERR_FOUND_OUT_OF_SCOPE", WERR_FOUND_OUT_OF_SCOPE },
+       { "WERR_ALLOCATE_BUCKET", WERR_ALLOCATE_BUCKET },
+       { "WERR_MARSHALL_OVERFLOW", WERR_MARSHALL_OVERFLOW },
+       { "WERR_INVALID_VARIANT", WERR_INVALID_VARIANT },
+       { "WERR_BAD_COMPRESSION_BUFFER", WERR_BAD_COMPRESSION_BUFFER },
+       { "WERR_AUDIT_FAILED", WERR_AUDIT_FAILED },
+       { "WERR_TIMER_RESOLUTION_NOT_SET", WERR_TIMER_RESOLUTION_NOT_SET },
+       { "WERR_INSUFFICIENT_LOGON_INFO", WERR_INSUFFICIENT_LOGON_INFO },
+       { "WERR_BAD_DLL_ENTRYPOINT", WERR_BAD_DLL_ENTRYPOINT },
+       { "WERR_BAD_SERVICE_ENTRYPOINT", WERR_BAD_SERVICE_ENTRYPOINT },
+       { "WERR_IP_ADDRESS_CONFLICT1", WERR_IP_ADDRESS_CONFLICT1 },
+       { "WERR_IP_ADDRESS_CONFLICT2", WERR_IP_ADDRESS_CONFLICT2 },
+       { "WERR_REGISTRY_QUOTA_LIMIT", WERR_REGISTRY_QUOTA_LIMIT },
+       { "WERR_NO_CALLBACK_ACTIVE", WERR_NO_CALLBACK_ACTIVE },
+       { "WERR_PWD_TOO_SHORT", WERR_PWD_TOO_SHORT },
+       { "WERR_PWD_TOO_RECENT", WERR_PWD_TOO_RECENT },
+       { "WERR_PWD_HISTORY_CONFLICT", WERR_PWD_HISTORY_CONFLICT },
+       { "WERR_UNSUPPORTED_COMPRESSION", WERR_UNSUPPORTED_COMPRESSION },
+       { "WERR_INVALID_HW_PROFILE", WERR_INVALID_HW_PROFILE },
+       { "WERR_INVALID_PLUGPLAY_DEVICE_PATH", WERR_INVALID_PLUGPLAY_DEVICE_PATH },
+       { "WERR_QUOTA_LIST_INCONSISTENT", WERR_QUOTA_LIST_INCONSISTENT },
+       { "WERR_EVALUATION_EXPIRATION", WERR_EVALUATION_EXPIRATION },
+       { "WERR_ILLEGAL_DLL_RELOCATION", WERR_ILLEGAL_DLL_RELOCATION },
+       { "WERR_DLL_INIT_FAILED_LOGOFF", WERR_DLL_INIT_FAILED_LOGOFF },
+       { "WERR_VALIDATE_CONTINUE", WERR_VALIDATE_CONTINUE },
+       { "WERR_NO_MORE_MATCHES", WERR_NO_MORE_MATCHES },
+       { "WERR_RANGE_LIST_CONFLICT", WERR_RANGE_LIST_CONFLICT },
+       { "WERR_SERVER_SID_MISMATCH", WERR_SERVER_SID_MISMATCH },
+       { "WERR_CANT_ENABLE_DENY_ONLY", WERR_CANT_ENABLE_DENY_ONLY },
+       { "WERR_FLOAT_MULTIPLE_FAULTS", WERR_FLOAT_MULTIPLE_FAULTS },
+       { "WERR_FLOAT_MULTIPLE_TRAPS", WERR_FLOAT_MULTIPLE_TRAPS },
+       { "WERR_NOINTERFACE", WERR_NOINTERFACE },
+       { "WERR_DRIVER_FAILED_SLEEP", WERR_DRIVER_FAILED_SLEEP },
+       { "WERR_CORRUPT_SYSTEM_FILE", WERR_CORRUPT_SYSTEM_FILE },
+       { "WERR_COMMITMENT_MINIMUM", WERR_COMMITMENT_MINIMUM },
+       { "WERR_PNP_RESTART_ENUMERATION", WERR_PNP_RESTART_ENUMERATION },
+       { "WERR_SYSTEM_IMAGE_BAD_SIGNATURE", WERR_SYSTEM_IMAGE_BAD_SIGNATURE },
+       { "WERR_PNP_REBOOT_REQUIRED", WERR_PNP_REBOOT_REQUIRED },
+       { "WERR_INSUFFICIENT_POWER", WERR_INSUFFICIENT_POWER },
+       { "WERR_MULTIPLE_FAULT_VIOLATION", WERR_MULTIPLE_FAULT_VIOLATION },
+       { "WERR_SYSTEM_SHUTDOWN", WERR_SYSTEM_SHUTDOWN },
+       { "WERR_PORT_NOT_SET", WERR_PORT_NOT_SET },
+       { "WERR_DS_VERSION_CHECK_FAILURE", WERR_DS_VERSION_CHECK_FAILURE },
+       { "WERR_RANGE_NOT_FOUND", WERR_RANGE_NOT_FOUND },
+       { "WERR_NOT_SAFE_MODE_DRIVER", WERR_NOT_SAFE_MODE_DRIVER },
+       { "WERR_FAILED_DRIVER_ENTRY", WERR_FAILED_DRIVER_ENTRY },
+       { "WERR_DEVICE_ENUMERATION_ERROR", WERR_DEVICE_ENUMERATION_ERROR },
+       { "WERR_MOUNT_POINT_NOT_RESOLVED", WERR_MOUNT_POINT_NOT_RESOLVED },
+       { "WERR_INVALID_DEVICE_OBJECT_PARAMETER", WERR_INVALID_DEVICE_OBJECT_PARAMETER },
+       { "WERR_MCA_OCCURED", WERR_MCA_OCCURED },
+       { "WERR_DRIVER_DATABASE_ERROR", WERR_DRIVER_DATABASE_ERROR },
+       { "WERR_SYSTEM_HIVE_TOO_LARGE", WERR_SYSTEM_HIVE_TOO_LARGE },
+       { "WERR_DRIVER_FAILED_PRIOR_UNLOAD", WERR_DRIVER_FAILED_PRIOR_UNLOAD },
+       { "WERR_VOLSNAP_PREPARE_HIBERNATE", WERR_VOLSNAP_PREPARE_HIBERNATE },
+       { "WERR_HIBERNATION_FAILURE", WERR_HIBERNATION_FAILURE },
+       { "WERR_FILE_SYSTEM_LIMITATION", WERR_FILE_SYSTEM_LIMITATION },
+       { "WERR_ASSERTION_FAILURE", WERR_ASSERTION_FAILURE },
+       { "WERR_ACPI_ERROR", WERR_ACPI_ERROR },
+       { "WERR_WOW_ASSERTION", WERR_WOW_ASSERTION },
+       { "WERR_PNP_BAD_MPS_TABLE", WERR_PNP_BAD_MPS_TABLE },
+       { "WERR_PNP_TRANSLATION_FAILED", WERR_PNP_TRANSLATION_FAILED },
+       { "WERR_PNP_IRQ_TRANSLATION_FAILED", WERR_PNP_IRQ_TRANSLATION_FAILED },
+       { "WERR_PNP_INVALID_ID", WERR_PNP_INVALID_ID },
+       { "WERR_WAKE_SYSTEM_DEBUGGER", WERR_WAKE_SYSTEM_DEBUGGER },
+       { "WERR_HANDLES_CLOSED", WERR_HANDLES_CLOSED },
+       { "WERR_EXTRANEOUS_INFORMATION", WERR_EXTRANEOUS_INFORMATION },
+       { "WERR_RXACT_COMMIT_NECESSARY", WERR_RXACT_COMMIT_NECESSARY },
+       { "WERR_MEDIA_CHECK", WERR_MEDIA_CHECK },
+       { "WERR_GUID_SUBSTITUTION_MADE", WERR_GUID_SUBSTITUTION_MADE },
+       { "WERR_STOPPED_ON_SYMLINK", WERR_STOPPED_ON_SYMLINK },
+       { "WERR_LONGJUMP", WERR_LONGJUMP },
+       { "WERR_PLUGPLAY_QUERY_VETOED", WERR_PLUGPLAY_QUERY_VETOED },
+       { "WERR_UNWIND_CONSOLIDATE", WERR_UNWIND_CONSOLIDATE },
+       { "WERR_REGISTRY_HIVE_RECOVERED", WERR_REGISTRY_HIVE_RECOVERED },
+       { "WERR_DLL_MIGHT_BE_INSECURE", WERR_DLL_MIGHT_BE_INSECURE },
+       { "WERR_DLL_MIGHT_BE_INCOMPATIBLE", WERR_DLL_MIGHT_BE_INCOMPATIBLE },
+       { "WERR_DBG_EXCEPTION_NOT_HANDLED", WERR_DBG_EXCEPTION_NOT_HANDLED },
+       { "WERR_DBG_REPLY_LATER", WERR_DBG_REPLY_LATER },
+       { "WERR_DBG_UNABLE_TO_PROVIDE_HANDLE", WERR_DBG_UNABLE_TO_PROVIDE_HANDLE },
+       { "WERR_DBG_TERMINATE_THREAD", WERR_DBG_TERMINATE_THREAD },
+       { "WERR_DBG_TERMINATE_PROCESS", WERR_DBG_TERMINATE_PROCESS },
+       { "WERR_DBG_CONTROL_C", WERR_DBG_CONTROL_C },
+       { "WERR_DBG_PRINTEXCEPTION_C", WERR_DBG_PRINTEXCEPTION_C },
+       { "WERR_DBG_RIPEXCEPTION", WERR_DBG_RIPEXCEPTION },
+       { "WERR_DBG_CONTROL_BREAK", WERR_DBG_CONTROL_BREAK },
+       { "WERR_DBG_COMMAND_EXCEPTION", WERR_DBG_COMMAND_EXCEPTION },
+       { "WERR_OBJECT_NAME_EXISTS", WERR_OBJECT_NAME_EXISTS },
+       { "WERR_THREAD_WAS_SUSPENDED", WERR_THREAD_WAS_SUSPENDED },
+       { "WERR_IMAGE_NOT_AT_BASE", WERR_IMAGE_NOT_AT_BASE },
+       { "WERR_RXACT_STATE_CREATED", WERR_RXACT_STATE_CREATED },
+       { "WERR_SEGMENT_NOTIFICATION", WERR_SEGMENT_NOTIFICATION },
+       { "WERR_BAD_CURRENT_DIRECTORY", WERR_BAD_CURRENT_DIRECTORY },
+       { "WERR_FT_READ_RECOVERY_FROM_BACKUP", WERR_FT_READ_RECOVERY_FROM_BACKUP },
+       { "WERR_FT_WRITE_RECOVERY", WERR_FT_WRITE_RECOVERY },
+       { "WERR_IMAGE_MACHINE_TYPE_MISMATCH", WERR_IMAGE_MACHINE_TYPE_MISMATCH },
+       { "WERR_RECEIVE_PARTIAL", WERR_RECEIVE_PARTIAL },
+       { "WERR_RECEIVE_EXPEDITED", WERR_RECEIVE_EXPEDITED },
+       { "WERR_RECEIVE_PARTIAL_EXPEDITED", WERR_RECEIVE_PARTIAL_EXPEDITED },
+       { "WERR_EVENT_DONE", WERR_EVENT_DONE },
+       { "WERR_EVENT_PENDING", WERR_EVENT_PENDING },
+       { "WERR_CHECKING_FILE_SYSTEM", WERR_CHECKING_FILE_SYSTEM },
+       { "WERR_FATAL_APP_EXIT", WERR_FATAL_APP_EXIT },
+       { "WERR_PREDEFINED_HANDLE", WERR_PREDEFINED_HANDLE },
+       { "WERR_WAS_UNLOCKED", WERR_WAS_UNLOCKED },
+       { "WERR_SERVICE_NOTIFICATION", WERR_SERVICE_NOTIFICATION },
+       { "WERR_WAS_LOCKED", WERR_WAS_LOCKED },
+       { "WERR_LOG_HARD_ERROR", WERR_LOG_HARD_ERROR },
+       { "WERR_ALREADY_WIN32", WERR_ALREADY_WIN32 },
+       { "WERR_IMAGE_MACHINE_TYPE_MISMATCH_EXE", WERR_IMAGE_MACHINE_TYPE_MISMATCH_EXE },
+       { "WERR_NO_YIELD_PERFORMED", WERR_NO_YIELD_PERFORMED },
+       { "WERR_TIMER_RESUME_IGNORED", WERR_TIMER_RESUME_IGNORED },
+       { "WERR_ARBITRATION_UNHANDLED", WERR_ARBITRATION_UNHANDLED },
+       { "WERR_CARDBUS_NOT_SUPPORTED", WERR_CARDBUS_NOT_SUPPORTED },
+       { "WERR_MP_PROCESSOR_MISMATCH", WERR_MP_PROCESSOR_MISMATCH },
+       { "WERR_HIBERNATED", WERR_HIBERNATED },
+       { "WERR_RESUME_HIBERNATION", WERR_RESUME_HIBERNATION },
+       { "WERR_FIRMWARE_UPDATED", WERR_FIRMWARE_UPDATED },
+       { "WERR_DRIVERS_LEAKING_LOCKED_PAGES", WERR_DRIVERS_LEAKING_LOCKED_PAGES },
+       { "WERR_WAKE_SYSTEM", WERR_WAKE_SYSTEM },
+       { "WERR_WAIT_1", WERR_WAIT_1 },
+       { "WERR_WAIT_2", WERR_WAIT_2 },
+       { "WERR_WAIT_3", WERR_WAIT_3 },
+       { "WERR_WAIT_63", WERR_WAIT_63 },
+       { "WERR_ABANDONED_WAIT_0", WERR_ABANDONED_WAIT_0 },
+       { "WERR_ABANDONED_WAIT_63", WERR_ABANDONED_WAIT_63 },
+       { "WERR_USER_APC", WERR_USER_APC },
+       { "WERR_KERNEL_APC", WERR_KERNEL_APC },
+       { "WERR_ALERTED", WERR_ALERTED },
+       { "WERR_ELEVATION_REQUIRED", WERR_ELEVATION_REQUIRED },
+       { "WERR_REPARSE", WERR_REPARSE },
+       { "WERR_OPLOCK_BREAK_IN_PROGRESS", WERR_OPLOCK_BREAK_IN_PROGRESS },
+       { "WERR_VOLUME_MOUNTED", WERR_VOLUME_MOUNTED },
+       { "WERR_RXACT_COMMITTED", WERR_RXACT_COMMITTED },
+       { "WERR_NOTIFY_CLEANUP", WERR_NOTIFY_CLEANUP },
+       { "WERR_PRIMARY_TRANSPORT_CONNECT_FAILED", WERR_PRIMARY_TRANSPORT_CONNECT_FAILED },
+       { "WERR_PAGE_FAULT_TRANSITION", WERR_PAGE_FAULT_TRANSITION },
+       { "WERR_PAGE_FAULT_DEMAND_ZERO", WERR_PAGE_FAULT_DEMAND_ZERO },
+       { "WERR_PAGE_FAULT_COPY_ON_WRITE", WERR_PAGE_FAULT_COPY_ON_WRITE },
+       { "WERR_PAGE_FAULT_GUARD_PAGE", WERR_PAGE_FAULT_GUARD_PAGE },
+       { "WERR_PAGE_FAULT_PAGING_FILE", WERR_PAGE_FAULT_PAGING_FILE },
+       { "WERR_CACHE_PAGE_LOCKED", WERR_CACHE_PAGE_LOCKED },
+       { "WERR_CRASH_DUMP", WERR_CRASH_DUMP },
+       { "WERR_BUFFER_ALL_ZEROS", WERR_BUFFER_ALL_ZEROS },
+       { "WERR_REPARSE_OBJECT", WERR_REPARSE_OBJECT },
+       { "WERR_RESOURCE_REQUIREMENTS_CHANGED", WERR_RESOURCE_REQUIREMENTS_CHANGED },
+       { "WERR_TRANSLATION_COMPLETE", WERR_TRANSLATION_COMPLETE },
+       { "WERR_NOTHING_TO_TERMINATE", WERR_NOTHING_TO_TERMINATE },
+       { "WERR_PROCESS_NOT_IN_JOB", WERR_PROCESS_NOT_IN_JOB },
+       { "WERR_PROCESS_IN_JOB", WERR_PROCESS_IN_JOB },
+       { "WERR_VOLSNAP_HIBERNATE_READY", WERR_VOLSNAP_HIBERNATE_READY },
+       { "WERR_FSFILTER_OP_COMPLETED_SUCCESSFULLY", WERR_FSFILTER_OP_COMPLETED_SUCCESSFULLY },
+       { "WERR_INTERRUPT_VECTOR_ALREADY_CONNECTED", WERR_INTERRUPT_VECTOR_ALREADY_CONNECTED },
+       { "WERR_INTERRUPT_STILL_CONNECTED", WERR_INTERRUPT_STILL_CONNECTED },
+       { "WERR_WAIT_FOR_OPLOCK", WERR_WAIT_FOR_OPLOCK },
+       { "WERR_DBG_EXCEPTION_HANDLED", WERR_DBG_EXCEPTION_HANDLED },
+       { "WERR_DBG_CONTINUE", WERR_DBG_CONTINUE },
+       { "WERR_CALLBACK_POP_STACK", WERR_CALLBACK_POP_STACK },
+       { "WERR_COMPRESSION_DISABLED", WERR_COMPRESSION_DISABLED },
+       { "WERR_CANTFETCHBACKWARDS", WERR_CANTFETCHBACKWARDS },
+       { "WERR_CANTSCROLLBACKWARDS", WERR_CANTSCROLLBACKWARDS },
+       { "WERR_ROWSNOTRELEASED", WERR_ROWSNOTRELEASED },
+       { "WERR_BAD_ACCESSOR_FLAGS", WERR_BAD_ACCESSOR_FLAGS },
+       { "WERR_ERRORS_ENCOUNTERED", WERR_ERRORS_ENCOUNTERED },
+       { "WERR_NOT_CAPABLE", WERR_NOT_CAPABLE },
+       { "WERR_REQUEST_OUT_OF_SEQUENCE", WERR_REQUEST_OUT_OF_SEQUENCE },
+       { "WERR_VERSION_PARSE_ERROR", WERR_VERSION_PARSE_ERROR },
+       { "WERR_BADSTARTPOSITION", WERR_BADSTARTPOSITION },
+       { "WERR_MEMORY_HARDWARE", WERR_MEMORY_HARDWARE },
+       { "WERR_DISK_REPAIR_DISABLED", WERR_DISK_REPAIR_DISABLED },
+       { "WERR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE", WERR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE },
+       { "WERR_SYSTEM_POWERSTATE_TRANSITION", WERR_SYSTEM_POWERSTATE_TRANSITION },
+       { "WERR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION", WERR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION },
+       { "WERR_MCA_EXCEPTION", WERR_MCA_EXCEPTION },
+       { "WERR_ACCESS_AUDIT_BY_POLICY", WERR_ACCESS_AUDIT_BY_POLICY },
+       { "WERR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY", WERR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY },
+       { "WERR_ABANDON_HIBERFILE", WERR_ABANDON_HIBERFILE },
+       { "WERR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED", WERR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED },
+       { "WERR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR", WERR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR },
+       { "WERR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR", WERR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR },
+       { "WERR_EA_ACCESS_DENIED", WERR_EA_ACCESS_DENIED },
+       { "WERR_OPERATION_ABORTED", WERR_OPERATION_ABORTED },
+       { "WERR_IO_INCOMPLETE", WERR_IO_INCOMPLETE },
+       { "WERR_NOACCESS", WERR_NOACCESS },
+       { "WERR_SWAPERROR", WERR_SWAPERROR },
+       { "WERR_STACK_OVERFLOW", WERR_STACK_OVERFLOW },
+       { "WERR_INVALID_MESSAGE", WERR_INVALID_MESSAGE },
+       { "WERR_UNRECOGNIZED_VOLUME", WERR_UNRECOGNIZED_VOLUME },
+       { "WERR_FILE_INVALID", WERR_FILE_INVALID },
+       { "WERR_FULLSCREEN_MODE", WERR_FULLSCREEN_MODE },
+       { "WERR_NO_TOKEN", WERR_NO_TOKEN },
+       { "WERR_BADDB", WERR_BADDB },
+       { "WERR_BADKEY", WERR_BADKEY },
+       { "WERR_CANTOPEN", WERR_CANTOPEN },
+       { "WERR_CANTREAD", WERR_CANTREAD },
+       { "WERR_CANTWRITE", WERR_CANTWRITE },
+       { "WERR_REGISTRY_RECOVERED", WERR_REGISTRY_RECOVERED },
+       { "WERR_REGISTRY_CORRUPT", WERR_REGISTRY_CORRUPT },
+       { "WERR_REGISTRY_IO_FAILED", WERR_REGISTRY_IO_FAILED },
+       { "WERR_NOT_REGISTRY_FILE", WERR_NOT_REGISTRY_FILE },
+       { "WERR_KEY_DELETED", WERR_KEY_DELETED },
+       { "WERR_NO_LOG_SPACE", WERR_NO_LOG_SPACE },
+       { "WERR_KEY_HAS_CHILDREN", WERR_KEY_HAS_CHILDREN },
+       { "WERR_CHILD_MUST_BE_VOLATILE", WERR_CHILD_MUST_BE_VOLATILE },
+       { "WERR_NOTIFY_ENUM_DIR", WERR_NOTIFY_ENUM_DIR },
+       { "WERR_DEPENDENT_SERVICES_RUNNING", WERR_DEPENDENT_SERVICES_RUNNING },
+       { "WERR_SERVICE_REQUEST_TIMEOUT", WERR_SERVICE_REQUEST_TIMEOUT },
+       { "WERR_SERVICE_NO_THREAD", WERR_SERVICE_NO_THREAD },
+       { "WERR_SERVICE_DATABASE_LOCKED", WERR_SERVICE_DATABASE_LOCKED },
+       { "WERR_INVALID_SERVICE_ACCOUNT", WERR_INVALID_SERVICE_ACCOUNT },
+       { "WERR_CIRCULAR_DEPENDENCY", WERR_CIRCULAR_DEPENDENCY },
+       { "WERR_SERVICE_DOES_NOT_EXIST", WERR_SERVICE_DOES_NOT_EXIST },
+       { "WERR_SERVICE_CANNOT_ACCEPT_CTRL", WERR_SERVICE_CANNOT_ACCEPT_CTRL },
+       { "WERR_SERVICE_NOT_ACTIVE", WERR_SERVICE_NOT_ACTIVE },
+       { "WERR_FAILED_SERVICE_CONTROLLER_CONNECT", WERR_FAILED_SERVICE_CONTROLLER_CONNECT },
+       { "WERR_EXCEPTION_IN_SERVICE", WERR_EXCEPTION_IN_SERVICE },
+       { "WERR_DATABASE_DOES_NOT_EXIST", WERR_DATABASE_DOES_NOT_EXIST },
+       { "WERR_SERVICE_SPECIFIC_ERROR", WERR_SERVICE_SPECIFIC_ERROR },
+       { "WERR_PROCESS_ABORTED", WERR_PROCESS_ABORTED },
+       { "WERR_SERVICE_DEPENDENCY_FAIL", WERR_SERVICE_DEPENDENCY_FAIL },
+       { "WERR_SERVICE_LOGON_FAILED", WERR_SERVICE_LOGON_FAILED },
+       { "WERR_SERVICE_START_HANG", WERR_SERVICE_START_HANG },
+       { "WERR_INVALID_SERVICE_LOCK", WERR_INVALID_SERVICE_LOCK },
+       { "WERR_ALREADY_RUNNING_LKG", WERR_ALREADY_RUNNING_LKG },
+       { "WERR_SERVICE_DEPENDENCY_DELETED", WERR_SERVICE_DEPENDENCY_DELETED },
+       { "WERR_BOOT_ALREADY_ACCEPTED", WERR_BOOT_ALREADY_ACCEPTED },
+       { "WERR_DIFFERENT_SERVICE_ACCOUNT", WERR_DIFFERENT_SERVICE_ACCOUNT },
+       { "WERR_CANNOT_DETECT_DRIVER_FAILURE", WERR_CANNOT_DETECT_DRIVER_FAILURE },
+       { "WERR_CANNOT_DETECT_PROCESS_ABORT", WERR_CANNOT_DETECT_PROCESS_ABORT },
+       { "WERR_NO_RECOVERY_PROGRAM", WERR_NO_RECOVERY_PROGRAM },
+       { "WERR_SERVICE_NOT_IN_EXE", WERR_SERVICE_NOT_IN_EXE },
+       { "WERR_NOT_SAFEBOOT_SERVICE", WERR_NOT_SAFEBOOT_SERVICE },
+       { "WERR_END_OF_MEDIA", WERR_END_OF_MEDIA },
+       { "WERR_FILEMARK_DETECTED", WERR_FILEMARK_DETECTED },
+       { "WERR_BEGINNING_OF_MEDIA", WERR_BEGINNING_OF_MEDIA },
+       { "WERR_SETMARK_DETECTED", WERR_SETMARK_DETECTED },
+       { "WERR_NO_DATA_DETECTED", WERR_NO_DATA_DETECTED },
+       { "WERR_PARTITION_FAILURE", WERR_PARTITION_FAILURE },
+       { "WERR_INVALID_BLOCK_LENGTH", WERR_INVALID_BLOCK_LENGTH },
+       { "WERR_DEVICE_NOT_PARTITIONED", WERR_DEVICE_NOT_PARTITIONED },
+       { "WERR_UNABLE_TO_LOCK_MEDIA", WERR_UNABLE_TO_LOCK_MEDIA },
+       { "WERR_UNABLE_TO_UNLOAD_MEDIA", WERR_UNABLE_TO_UNLOAD_MEDIA },
+       { "WERR_MEDIA_CHANGED", WERR_MEDIA_CHANGED },
+       { "WERR_BUS_RESET", WERR_BUS_RESET },
+       { "WERR_NO_MEDIA_IN_DRIVE", WERR_NO_MEDIA_IN_DRIVE },
+       { "WERR_NO_UNICODE_TRANSLATION", WERR_NO_UNICODE_TRANSLATION },
+       { "WERR_DLL_INIT_FAILED", WERR_DLL_INIT_FAILED },
+       { "WERR_SHUTDOWN_IN_PROGRESS", WERR_SHUTDOWN_IN_PROGRESS },
+       { "WERR_IO_DEVICE", WERR_IO_DEVICE },
+       { "WERR_SERIAL_NO_DEVICE", WERR_SERIAL_NO_DEVICE },
+       { "WERR_IRQ_BUSY", WERR_IRQ_BUSY },
+       { "WERR_MORE_WRITES", WERR_MORE_WRITES },
+       { "WERR_COUNTER_TIMEOUT", WERR_COUNTER_TIMEOUT },
+       { "WERR_FLOPPY_ID_MARK_NOT_FOUND", WERR_FLOPPY_ID_MARK_NOT_FOUND },
+       { "WERR_FLOPPY_WRONG_CYLINDER", WERR_FLOPPY_WRONG_CYLINDER },
+       { "WERR_FLOPPY_UNKNOWN_ERROR", WERR_FLOPPY_UNKNOWN_ERROR },
+       { "WERR_FLOPPY_BAD_REGISTERS", WERR_FLOPPY_BAD_REGISTERS },
+       { "WERR_DISK_RECALIBRATE_FAILED", WERR_DISK_RECALIBRATE_FAILED },
+       { "WERR_DISK_OPERATION_FAILED", WERR_DISK_OPERATION_FAILED },
+       { "WERR_DISK_RESET_FAILED", WERR_DISK_RESET_FAILED },
+       { "WERR_EOM_OVERFLOW", WERR_EOM_OVERFLOW },
+       { "WERR_NOT_ENOUGH_SERVER_MEMORY", WERR_NOT_ENOUGH_SERVER_MEMORY },
+       { "WERR_POSSIBLE_DEADLOCK", WERR_POSSIBLE_DEADLOCK },
+       { "WERR_MAPPED_ALIGNMENT", WERR_MAPPED_ALIGNMENT },
+       { "WERR_SET_POWER_STATE_VETOED", WERR_SET_POWER_STATE_VETOED },
+       { "WERR_SET_POWER_STATE_FAILED", WERR_SET_POWER_STATE_FAILED },
+       { "WERR_TOO_MANY_LINKS", WERR_TOO_MANY_LINKS },
+       { "WERR_OLD_WIN_VERSION", WERR_OLD_WIN_VERSION },
+       { "WERR_APP_WRONG_OS", WERR_APP_WRONG_OS },
+       { "WERR_SINGLE_INSTANCE_APP", WERR_SINGLE_INSTANCE_APP },
+       { "WERR_RMODE_APP", WERR_RMODE_APP },
+       { "WERR_INVALID_DLL", WERR_INVALID_DLL },
+       { "WERR_NO_ASSOCIATION", WERR_NO_ASSOCIATION },
+       { "WERR_DDE_FAIL", WERR_DDE_FAIL },
+       { "WERR_DLL_NOT_FOUND", WERR_DLL_NOT_FOUND },
+       { "WERR_NO_MORE_USER_HANDLES", WERR_NO_MORE_USER_HANDLES },
+       { "WERR_MESSAGE_SYNC_ONLY", WERR_MESSAGE_SYNC_ONLY },
+       { "WERR_SOURCE_ELEMENT_EMPTY", WERR_SOURCE_ELEMENT_EMPTY },
+       { "WERR_DESTINATION_ELEMENT_FULL", WERR_DESTINATION_ELEMENT_FULL },
+       { "WERR_ILLEGAL_ELEMENT_ADDRESS", WERR_ILLEGAL_ELEMENT_ADDRESS },
+       { "WERR_MAGAZINE_NOT_PRESENT", WERR_MAGAZINE_NOT_PRESENT },
+       { "WERR_DEVICE_REINITIALIZATION_NEEDED", WERR_DEVICE_REINITIALIZATION_NEEDED },
+       { "WERR_DEVICE_REQUIRES_CLEANING", WERR_DEVICE_REQUIRES_CLEANING },
+       { "WERR_DEVICE_DOOR_OPEN", WERR_DEVICE_DOOR_OPEN },
+       { "WERR_NO_MATCH", WERR_NO_MATCH },
+       { "WERR_SET_NOT_FOUND", WERR_SET_NOT_FOUND },
+       { "WERR_POINT_NOT_FOUND", WERR_POINT_NOT_FOUND },
+       { "WERR_NO_TRACKING_SERVICE", WERR_NO_TRACKING_SERVICE },
+       { "WERR_NO_VOLUME_ID", WERR_NO_VOLUME_ID },
+       { "WERR_UNABLE_TO_REMOVE_REPLACED", WERR_UNABLE_TO_REMOVE_REPLACED },
+       { "WERR_UNABLE_TO_MOVE_REPLACEMENT", WERR_UNABLE_TO_MOVE_REPLACEMENT },
+       { "WERR_UNABLE_TO_MOVE_REPLACEMENT_2", WERR_UNABLE_TO_MOVE_REPLACEMENT_2 },
+       { "WERR_JOURNAL_DELETE_IN_PROGRESS", WERR_JOURNAL_DELETE_IN_PROGRESS },
+       { "WERR_JOURNAL_NOT_ACTIVE", WERR_JOURNAL_NOT_ACTIVE },
+       { "WERR_POTENTIAL_FILE_FOUND", WERR_POTENTIAL_FILE_FOUND },
+       { "WERR_JOURNAL_ENTRY_DELETED", WERR_JOURNAL_ENTRY_DELETED },
+       { "WERR_SHUTDOWN_IS_SCHEDULED", WERR_SHUTDOWN_IS_SCHEDULED },
+       { "WERR_SHUTDOWN_USERS_LOGGED_ON", WERR_SHUTDOWN_USERS_LOGGED_ON },
+       { "WERR_BAD_DEVICE", WERR_BAD_DEVICE },
+       { "WERR_CONNECTION_UNAVAIL", WERR_CONNECTION_UNAVAIL },
+       { "WERR_DEVICE_ALREADY_REMEMBERED", WERR_DEVICE_ALREADY_REMEMBERED },
+       { "WERR_NO_NET_OR_BAD_PATH", WERR_NO_NET_OR_BAD_PATH },
+       { "WERR_BAD_PROVIDER", WERR_BAD_PROVIDER },
+       { "WERR_CANNOT_OPEN_PROFILE", WERR_CANNOT_OPEN_PROFILE },
+       { "WERR_BAD_PROFILE", WERR_BAD_PROFILE },
+       { "WERR_NOT_CONTAINER", WERR_NOT_CONTAINER },
+       { "WERR_EXTENDED_ERROR", WERR_EXTENDED_ERROR },
+       { "WERR_INVALID_GROUPNAME", WERR_INVALID_GROUPNAME },
+       { "WERR_INVALID_EVENTNAME", WERR_INVALID_EVENTNAME },
+       { "WERR_INVALID_SERVICENAME", WERR_INVALID_SERVICENAME },
+       { "WERR_INVALID_NETNAME", WERR_INVALID_NETNAME },
+       { "WERR_INVALID_SHARENAME", WERR_INVALID_SHARENAME },
+       { "WERR_INVALID_PASSWORDNAME", WERR_INVALID_PASSWORDNAME },
+       { "WERR_INVALID_MESSAGENAME", WERR_INVALID_MESSAGENAME },
+       { "WERR_INVALID_MESSAGEDEST", WERR_INVALID_MESSAGEDEST },
+       { "WERR_SESSION_CREDENTIAL_CONFLICT", WERR_SESSION_CREDENTIAL_CONFLICT },
+       { "WERR_REMOTE_SESSION_LIMIT_EXCEEDED", WERR_REMOTE_SESSION_LIMIT_EXCEEDED },
+       { "WERR_DUP_DOMAINNAME", WERR_DUP_DOMAINNAME },
+       { "WERR_NO_NETWORK", WERR_NO_NETWORK },
+       { "WERR_CANCELLED", WERR_CANCELLED },
+       { "WERR_USER_MAPPED_FILE", WERR_USER_MAPPED_FILE },
+       { "WERR_CONNECTION_REFUSED", WERR_CONNECTION_REFUSED },
+       { "WERR_GRACEFUL_DISCONNECT", WERR_GRACEFUL_DISCONNECT },
+       { "WERR_ADDRESS_ALREADY_ASSOCIATED", WERR_ADDRESS_ALREADY_ASSOCIATED },
+       { "WERR_ADDRESS_NOT_ASSOCIATED", WERR_ADDRESS_NOT_ASSOCIATED },
+       { "WERR_CONNECTION_INVALID", WERR_CONNECTION_INVALID },
+       { "WERR_CONNECTION_ACTIVE", WERR_CONNECTION_ACTIVE },
+       { "WERR_NETWORK_UNREACHABLE", WERR_NETWORK_UNREACHABLE },
+       { "WERR_HOST_UNREACHABLE", WERR_HOST_UNREACHABLE },
+       { "WERR_PROTOCOL_UNREACHABLE", WERR_PROTOCOL_UNREACHABLE },
+       { "WERR_PORT_UNREACHABLE", WERR_PORT_UNREACHABLE },
+       { "WERR_REQUEST_ABORTED", WERR_REQUEST_ABORTED },
+       { "WERR_CONNECTION_ABORTED", WERR_CONNECTION_ABORTED },
+       { "WERR_RETRY", WERR_RETRY },
+       { "WERR_CONNECTION_COUNT_LIMIT", WERR_CONNECTION_COUNT_LIMIT },
+       { "WERR_LOGIN_TIME_RESTRICTION", WERR_LOGIN_TIME_RESTRICTION },
+       { "WERR_LOGIN_WKSTA_RESTRICTION", WERR_LOGIN_WKSTA_RESTRICTION },
+       { "WERR_INCORRECT_ADDRESS", WERR_INCORRECT_ADDRESS },
+       { "WERR_ALREADY_REGISTERED", WERR_ALREADY_REGISTERED },
+       { "WERR_SERVICE_NOT_FOUND", WERR_SERVICE_NOT_FOUND },
+       { "WERR_NOT_LOGGED_ON", WERR_NOT_LOGGED_ON },
+       { "WERR_CONTINUE", WERR_CONTINUE },
+       { "WERR_ALREADY_INITIALIZED", WERR_ALREADY_INITIALIZED },
+       { "WERR_NO_MORE_DEVICES", WERR_NO_MORE_DEVICES },
+       { "WERR_NO_SUCH_SITE", WERR_NO_SUCH_SITE },
+       { "WERR_DOMAIN_CONTROLLER_EXISTS", WERR_DOMAIN_CONTROLLER_EXISTS },
+       { "WERR_ONLY_IF_CONNECTED", WERR_ONLY_IF_CONNECTED },
+       { "WERR_OVERRIDE_NOCHANGES", WERR_OVERRIDE_NOCHANGES },
+       { "WERR_BAD_USER_PROFILE", WERR_BAD_USER_PROFILE },
+       { "WERR_NOT_SUPPORTED_ON_SBS", WERR_NOT_SUPPORTED_ON_SBS },
+       { "WERR_SERVER_SHUTDOWN_IN_PROGRESS", WERR_SERVER_SHUTDOWN_IN_PROGRESS },
+       { "WERR_HOST_DOWN", WERR_HOST_DOWN },
+       { "WERR_NON_ACCOUNT_SID", WERR_NON_ACCOUNT_SID },
+       { "WERR_NON_DOMAIN_SID", WERR_NON_DOMAIN_SID },
+       { "WERR_APPHELP_BLOCK", WERR_APPHELP_BLOCK },
+       { "WERR_ACCESS_DISABLED_BY_POLICY", WERR_ACCESS_DISABLED_BY_POLICY },
+       { "WERR_REG_NAT_CONSUMPTION", WERR_REG_NAT_CONSUMPTION },
+       { "WERR_CSCSHARE_OFFLINE", WERR_CSCSHARE_OFFLINE },
+       { "WERR_PKINIT_FAILURE", WERR_PKINIT_FAILURE },
+       { "WERR_SMARTCARD_SUBSYSTEM_FAILURE", WERR_SMARTCARD_SUBSYSTEM_FAILURE },
+       { "WERR_DOWNGRADE_DETECTED", WERR_DOWNGRADE_DETECTED },
+       { "WERR_CALLBACK_SUPPLIED_INVALID_DATA", WERR_CALLBACK_SUPPLIED_INVALID_DATA },
+       { "WERR_SYNC_FOREGROUND_REFRESH_REQUIRED", WERR_SYNC_FOREGROUND_REFRESH_REQUIRED },
+       { "WERR_DRIVER_BLOCKED", WERR_DRIVER_BLOCKED },
+       { "WERR_INVALID_IMPORT_OF_NON_DLL", WERR_INVALID_IMPORT_OF_NON_DLL },
+       { "WERR_ACCESS_DISABLED_WEBBLADE", WERR_ACCESS_DISABLED_WEBBLADE },
+       { "WERR_ACCESS_DISABLED_WEBBLADE_TAMPER", WERR_ACCESS_DISABLED_WEBBLADE_TAMPER },
+       { "WERR_RECOVERY_FAILURE", WERR_RECOVERY_FAILURE },
+       { "WERR_ALREADY_FIBER", WERR_ALREADY_FIBER },
+       { "WERR_ALREADY_THREAD", WERR_ALREADY_THREAD },
+       { "WERR_STACK_BUFFER_OVERRUN", WERR_STACK_BUFFER_OVERRUN },
+       { "WERR_PARAMETER_QUOTA_EXCEEDED", WERR_PARAMETER_QUOTA_EXCEEDED },
+       { "WERR_DEBUGGER_INACTIVE", WERR_DEBUGGER_INACTIVE },
+       { "WERR_DELAY_LOAD_FAILED", WERR_DELAY_LOAD_FAILED },
+       { "WERR_VDM_DISALLOWED", WERR_VDM_DISALLOWED },
+       { "WERR_UNIDENTIFIED_ERROR", WERR_UNIDENTIFIED_ERROR },
+       { "WERR_BEYOND_VDL", WERR_BEYOND_VDL },
+       { "WERR_INCOMPATIBLE_SERVICE_SID_TYPE", WERR_INCOMPATIBLE_SERVICE_SID_TYPE },
+       { "WERR_DRIVER_PROCESS_TERMINATED", WERR_DRIVER_PROCESS_TERMINATED },
+       { "WERR_IMPLEMENTATION_LIMIT", WERR_IMPLEMENTATION_LIMIT },
+       { "WERR_PROCESS_IS_PROTECTED", WERR_PROCESS_IS_PROTECTED },
+       { "WERR_SERVICE_NOTIFY_CLIENT_LAGGING", WERR_SERVICE_NOTIFY_CLIENT_LAGGING },
+       { "WERR_DISK_QUOTA_EXCEEDED", WERR_DISK_QUOTA_EXCEEDED },
+       { "WERR_CONTENT_BLOCKED", WERR_CONTENT_BLOCKED },
+       { "WERR_INCOMPATIBLE_SERVICE_PRIVILEGE", WERR_INCOMPATIBLE_SERVICE_PRIVILEGE },
+       { "WERR_INVALID_LABEL", WERR_INVALID_LABEL },
+       { "WERR_NOT_ALL_ASSIGNED", WERR_NOT_ALL_ASSIGNED },
+       { "WERR_SOME_NOT_MAPPED", WERR_SOME_NOT_MAPPED },
+       { "WERR_NO_QUOTAS_FOR_ACCOUNT", WERR_NO_QUOTAS_FOR_ACCOUNT },
+       { "WERR_LOCAL_USER_SESSION_KEY", WERR_LOCAL_USER_SESSION_KEY },
+       { "WERR_NULL_LM_PASSWORD", WERR_NULL_LM_PASSWORD },
+       { "WERR_NO_IMPERSONATION_TOKEN", WERR_NO_IMPERSONATION_TOKEN },
+       { "WERR_CANT_DISABLE_MANDATORY", WERR_CANT_DISABLE_MANDATORY },
+       { "WERR_INVALID_ACCOUNT_NAME", WERR_INVALID_ACCOUNT_NAME },
+       { "WERR_USER_EXISTS", WERR_USER_EXISTS },
+       { "WERR_MEMBER_NOT_IN_GROUP", WERR_MEMBER_NOT_IN_GROUP },
+       { "WERR_LAST_ADMIN", WERR_LAST_ADMIN },
+       { "WERR_ILL_FORMED_PASSWORD", WERR_ILL_FORMED_PASSWORD },
+       { "WERR_ACCOUNT_RESTRICTION", WERR_ACCOUNT_RESTRICTION },
+       { "WERR_INVALID_LOGON_HOURS", WERR_INVALID_LOGON_HOURS },
+       { "WERR_INVALID_WORKSTATION", WERR_INVALID_WORKSTATION },
+       { "WERR_PASSWORD_EXPIRED", WERR_PASSWORD_EXPIRED },
+       { "WERR_ACCOUNT_DISABLED", WERR_ACCOUNT_DISABLED },
+       { "WERR_TOO_MANY_LUIDS_REQUESTED", WERR_TOO_MANY_LUIDS_REQUESTED },
+       { "WERR_LUIDS_EXHAUSTED", WERR_LUIDS_EXHAUSTED },
+       { "WERR_INVALID_SUB_AUTHORITY", WERR_INVALID_SUB_AUTHORITY },
+       { "WERR_INVALID_ACL", WERR_INVALID_ACL },
+       { "WERR_INVALID_SID", WERR_INVALID_SID },
+       { "WERR_INVALID_SECURITY_DESCR", WERR_INVALID_SECURITY_DESCR },
+       { "WERR_BAD_INHERITANCE_ACL", WERR_BAD_INHERITANCE_ACL },
+       { "WERR_SERVER_DISABLED", WERR_SERVER_DISABLED },
+       { "WERR_SERVER_NOT_DISABLED", WERR_SERVER_NOT_DISABLED },
+       { "WERR_INVALID_ID_AUTHORITY", WERR_INVALID_ID_AUTHORITY },
+       { "WERR_ALLOTTED_SPACE_EXCEEDED", WERR_ALLOTTED_SPACE_EXCEEDED },
+       { "WERR_INVALID_GROUP_ATTRIBUTES", WERR_INVALID_GROUP_ATTRIBUTES },
+       { "WERR_BAD_IMPERSONATION_LEVEL", WERR_BAD_IMPERSONATION_LEVEL },
+       { "WERR_CANT_OPEN_ANONYMOUS", WERR_CANT_OPEN_ANONYMOUS },
+       { "WERR_BAD_VALIDATION_CLASS", WERR_BAD_VALIDATION_CLASS },
+       { "WERR_BAD_TOKEN_TYPE", WERR_BAD_TOKEN_TYPE },
+       { "WERR_NO_SECURITY_ON_OBJECT", WERR_NO_SECURITY_ON_OBJECT },
+       { "WERR_CANT_ACCESS_DOMAIN_INFO", WERR_CANT_ACCESS_DOMAIN_INFO },
+       { "WERR_INVALID_SERVER_STATE", WERR_INVALID_SERVER_STATE },
+       { "WERR_DOMAIN_EXISTS", WERR_DOMAIN_EXISTS },
+       { "WERR_DOMAIN_LIMIT_EXCEEDED", WERR_DOMAIN_LIMIT_EXCEEDED },
+       { "WERR_INTERNAL_DB_CORRUPTION", WERR_INTERNAL_DB_CORRUPTION },
+       { "WERR_INTERNAL_ERROR", WERR_INTERNAL_ERROR },
+       { "WERR_GENERIC_NOT_MAPPED", WERR_GENERIC_NOT_MAPPED },
+       { "WERR_BAD_DESCRIPTOR_FORMAT", WERR_BAD_DESCRIPTOR_FORMAT },
+       { "WERR_NOT_LOGON_PROCESS", WERR_NOT_LOGON_PROCESS },
+       { "WERR_LOGON_SESSION_EXISTS", WERR_LOGON_SESSION_EXISTS },
+       { "WERR_NO_SUCH_PACKAGE", WERR_NO_SUCH_PACKAGE },
+       { "WERR_BAD_LOGON_SESSION_STATE", WERR_BAD_LOGON_SESSION_STATE },
+       { "WERR_LOGON_SESSION_COLLISION", WERR_LOGON_SESSION_COLLISION },
+       { "WERR_INVALID_LOGON_TYPE", WERR_INVALID_LOGON_TYPE },
+       { "WERR_CANNOT_IMPERSONATE", WERR_CANNOT_IMPERSONATE },
+       { "WERR_RXACT_INVALID_STATE", WERR_RXACT_INVALID_STATE },
+       { "WERR_RXACT_COMMIT_FAILURE", WERR_RXACT_COMMIT_FAILURE },
+       { "WERR_SPECIAL_GROUP", WERR_SPECIAL_GROUP },
+       { "WERR_SPECIAL_USER", WERR_SPECIAL_USER },
+       { "WERR_MEMBERS_PRIMARY_GROUP", WERR_MEMBERS_PRIMARY_GROUP },
+       { "WERR_TOKEN_ALREADY_IN_USE", WERR_TOKEN_ALREADY_IN_USE },
+       { "WERR_MEMBER_NOT_IN_ALIAS", WERR_MEMBER_NOT_IN_ALIAS },
+       { "WERR_LOGON_NOT_GRANTED", WERR_LOGON_NOT_GRANTED },
+       { "WERR_TOO_MANY_SECRETS", WERR_TOO_MANY_SECRETS },
+       { "WERR_SECRET_TOO_LONG", WERR_SECRET_TOO_LONG },
+       { "WERR_INTERNAL_DB_ERROR", WERR_INTERNAL_DB_ERROR },
+       { "WERR_TOO_MANY_CONTEXT_IDS", WERR_TOO_MANY_CONTEXT_IDS },
+       { "WERR_LOGON_TYPE_NOT_GRANTED", WERR_LOGON_TYPE_NOT_GRANTED },
+       { "WERR_NT_CROSS_ENCRYPTION_REQUIRED", WERR_NT_CROSS_ENCRYPTION_REQUIRED },
+       { "WERR_NO_SUCH_MEMBER", WERR_NO_SUCH_MEMBER },
+       { "WERR_INVALID_MEMBER", WERR_INVALID_MEMBER },
+       { "WERR_TOO_MANY_SIDS", WERR_TOO_MANY_SIDS },
+       { "WERR_LM_CROSS_ENCRYPTION_REQUIRED", WERR_LM_CROSS_ENCRYPTION_REQUIRED },
+       { "WERR_NO_INHERITANCE", WERR_NO_INHERITANCE },
+       { "WERR_FILE_CORRUPT", WERR_FILE_CORRUPT },
+       { "WERR_DISK_CORRUPT", WERR_DISK_CORRUPT },
+       { "WERR_NO_USER_SESSION_KEY", WERR_NO_USER_SESSION_KEY },
+       { "WERR_LICENSE_QUOTA_EXCEEDED", WERR_LICENSE_QUOTA_EXCEEDED },
+       { "WERR_WRONG_TARGET_NAME", WERR_WRONG_TARGET_NAME },
+       { "WERR_MUTUAL_AUTH_FAILED", WERR_MUTUAL_AUTH_FAILED },
+       { "WERR_CURRENT_DOMAIN_NOT_ALLOWED", WERR_CURRENT_DOMAIN_NOT_ALLOWED },
+       { "WERR_INVALID_WINDOW_HANDLE", WERR_INVALID_WINDOW_HANDLE },
+       { "WERR_INVALID_MENU_HANDLE", WERR_INVALID_MENU_HANDLE },
+       { "WERR_INVALID_CURSOR_HANDLE", WERR_INVALID_CURSOR_HANDLE },
+       { "WERR_INVALID_ACCEL_HANDLE", WERR_INVALID_ACCEL_HANDLE },
+       { "WERR_INVALID_HOOK_HANDLE", WERR_INVALID_HOOK_HANDLE },
+       { "WERR_INVALID_DWP_HANDLE", WERR_INVALID_DWP_HANDLE },
+       { "WERR_TLW_WITH_WSCHILD", WERR_TLW_WITH_WSCHILD },
+       { "WERR_CANNOT_FIND_WND_CLASS", WERR_CANNOT_FIND_WND_CLASS },
+       { "WERR_WINDOW_OF_OTHER_THREAD", WERR_WINDOW_OF_OTHER_THREAD },
+       { "WERR_HOTKEY_ALREADY_REGISTERED", WERR_HOTKEY_ALREADY_REGISTERED },
+       { "WERR_CLASS_ALREADY_EXISTS", WERR_CLASS_ALREADY_EXISTS },
+       { "WERR_CLASS_DOES_NOT_EXIST", WERR_CLASS_DOES_NOT_EXIST },
+       { "WERR_CLASS_HAS_WINDOWS", WERR_CLASS_HAS_WINDOWS },
+       { "WERR_INVALID_INDEX", WERR_INVALID_INDEX },
+       { "WERR_INVALID_ICON_HANDLE", WERR_INVALID_ICON_HANDLE },
+       { "WERR_PRIVATE_DIALOG_INDEX", WERR_PRIVATE_DIALOG_INDEX },
+       { "WERR_LISTBOX_ID_NOT_FOUND", WERR_LISTBOX_ID_NOT_FOUND },
+       { "WERR_NO_WILDCARD_CHARACTERS", WERR_NO_WILDCARD_CHARACTERS },
+       { "WERR_CLIPBOARD_NOT_OPEN", WERR_CLIPBOARD_NOT_OPEN },
+       { "WERR_HOTKEY_NOT_REGISTERED", WERR_HOTKEY_NOT_REGISTERED },
+       { "WERR_WINDOW_NOT_DIALOG", WERR_WINDOW_NOT_DIALOG },
+       { "WERR_CONTROL_ID_NOT_FOUND", WERR_CONTROL_ID_NOT_FOUND },
+       { "WERR_INVALID_COMBOBOX_MESSAGE", WERR_INVALID_COMBOBOX_MESSAGE },
+       { "WERR_WINDOW_NOT_COMBOBOX", WERR_WINDOW_NOT_COMBOBOX },
+       { "WERR_INVALID_EDIT_HEIGHT", WERR_INVALID_EDIT_HEIGHT },
+       { "WERR_DC_NOT_FOUND", WERR_DC_NOT_FOUND },
+       { "WERR_INVALID_HOOK_FILTER", WERR_INVALID_HOOK_FILTER },
+       { "WERR_INVALID_FILTER_PROC", WERR_INVALID_FILTER_PROC },
+       { "WERR_HOOK_NEEDS_HMOD", WERR_HOOK_NEEDS_HMOD },
+       { "WERR_GLOBAL_ONLY_HOOK", WERR_GLOBAL_ONLY_HOOK },
+       { "WERR_JOURNAL_HOOK_SET", WERR_JOURNAL_HOOK_SET },
+       { "WERR_HOOK_NOT_INSTALLED", WERR_HOOK_NOT_INSTALLED },
+       { "WERR_INVALID_LB_MESSAGE", WERR_INVALID_LB_MESSAGE },
+       { "WERR_SETCOUNT_ON_BAD_LB", WERR_SETCOUNT_ON_BAD_LB },
+       { "WERR_LB_WITHOUT_TABSTOPS", WERR_LB_WITHOUT_TABSTOPS },
+       { "WERR_DESTROY_OBJECT_OF_OTHER_THREAD", WERR_DESTROY_OBJECT_OF_OTHER_THREAD },
+       { "WERR_CHILD_WINDOW_MENU", WERR_CHILD_WINDOW_MENU },
+       { "WERR_NO_SYSTEM_MENU", WERR_NO_SYSTEM_MENU },
+       { "WERR_INVALID_MSGBOX_STYLE", WERR_INVALID_MSGBOX_STYLE },
+       { "WERR_INVALID_SPI_VALUE", WERR_INVALID_SPI_VALUE },
+       { "WERR_SCREEN_ALREADY_LOCKED", WERR_SCREEN_ALREADY_LOCKED },
+       { "WERR_HWNDS_HAVE_DIFF_PARENT", WERR_HWNDS_HAVE_DIFF_PARENT },
+       { "WERR_NOT_CHILD_WINDOW", WERR_NOT_CHILD_WINDOW },
+       { "WERR_INVALID_GW_COMMAND", WERR_INVALID_GW_COMMAND },
+       { "WERR_INVALID_THREAD_ID", WERR_INVALID_THREAD_ID },
+       { "WERR_NON_MDICHILD_WINDOW", WERR_NON_MDICHILD_WINDOW },
+       { "WERR_POPUP_ALREADY_ACTIVE", WERR_POPUP_ALREADY_ACTIVE },
+       { "WERR_NO_SCROLLBARS", WERR_NO_SCROLLBARS },
+       { "WERR_INVALID_SCROLLBAR_RANGE", WERR_INVALID_SCROLLBAR_RANGE },
+       { "WERR_INVALID_SHOWWIN_COMMAND", WERR_INVALID_SHOWWIN_COMMAND },
+       { "WERR_NONPAGED_SYSTEM_RESOURCES", WERR_NONPAGED_SYSTEM_RESOURCES },
+       { "WERR_PAGED_SYSTEM_RESOURCES", WERR_PAGED_SYSTEM_RESOURCES },
+       { "WERR_WORKING_SET_QUOTA", WERR_WORKING_SET_QUOTA },
+       { "WERR_PAGEFILE_QUOTA", WERR_PAGEFILE_QUOTA },
+       { "WERR_COMMITMENT_LIMIT", WERR_COMMITMENT_LIMIT },
+       { "WERR_MENU_ITEM_NOT_FOUND", WERR_MENU_ITEM_NOT_FOUND },
+       { "WERR_INVALID_KEYBOARD_HANDLE", WERR_INVALID_KEYBOARD_HANDLE },
+       { "WERR_HOOK_TYPE_NOT_ALLOWED", WERR_HOOK_TYPE_NOT_ALLOWED },
+       { "WERR_REQUIRES_INTERACTIVE_WINDOWSTATION", WERR_REQUIRES_INTERACTIVE_WINDOWSTATION },
+       { "WERR_TIMEOUT", WERR_TIMEOUT },
+       { "WERR_INVALID_MONITOR_HANDLE", WERR_INVALID_MONITOR_HANDLE },
+       { "WERR_INCORRECT_SIZE", WERR_INCORRECT_SIZE },
+       { "WERR_SYMLINK_CLASS_DISABLED", WERR_SYMLINK_CLASS_DISABLED },
+       { "WERR_SYMLINK_NOT_SUPPORTED", WERR_SYMLINK_NOT_SUPPORTED },
+       { "WERR_EVENTLOG_CANT_START", WERR_EVENTLOG_CANT_START },
+       { "WERR_LOG_FILE_FULL", WERR_LOG_FILE_FULL },
+       { "WERR_EVENTLOG_FILE_CHANGED", WERR_EVENTLOG_FILE_CHANGED },
+       { "WERR_INVALID_TASK_NAME", WERR_INVALID_TASK_NAME },
+       { "WERR_INVALID_TASK_INDEX", WERR_INVALID_TASK_INDEX },
+       { "WERR_THREAD_ALREADY_IN_TASK", WERR_THREAD_ALREADY_IN_TASK },
+       { "WERR_INSTALL_SERVICE_FAILURE", WERR_INSTALL_SERVICE_FAILURE },
+       { "WERR_INSTALL_USEREXIT", WERR_INSTALL_USEREXIT },
+       { "WERR_INSTALL_FAILURE", WERR_INSTALL_FAILURE },
+       { "WERR_INSTALL_SUSPEND", WERR_INSTALL_SUSPEND },
+       { "WERR_UNKNOWN_PRODUCT", WERR_UNKNOWN_PRODUCT },
+       { "WERR_UNKNOWN_FEATURE", WERR_UNKNOWN_FEATURE },
+       { "WERR_UNKNOWN_COMPONENT", WERR_UNKNOWN_COMPONENT },
+       { "WERR_UNKNOWN_PROPERTY", WERR_UNKNOWN_PROPERTY },
+       { "WERR_INVALID_HANDLE_STATE", WERR_INVALID_HANDLE_STATE },
+       { "WERR_BAD_CONFIGURATION", WERR_BAD_CONFIGURATION },
+       { "WERR_INDEX_ABSENT", WERR_INDEX_ABSENT },
+       { "WERR_INSTALL_SOURCE_ABSENT", WERR_INSTALL_SOURCE_ABSENT },
+       { "WERR_INSTALL_PACKAGE_VERSION", WERR_INSTALL_PACKAGE_VERSION },
+       { "WERR_PRODUCT_UNINSTALLED", WERR_PRODUCT_UNINSTALLED },
+       { "WERR_BAD_QUERY_SYNTAX", WERR_BAD_QUERY_SYNTAX },
+       { "WERR_INVALID_FIELD", WERR_INVALID_FIELD },
+       { "WERR_DEVICE_REMOVED", WERR_DEVICE_REMOVED },
+       { "WERR_INSTALL_ALREADY_RUNNING", WERR_INSTALL_ALREADY_RUNNING },
+       { "WERR_INSTALL_PACKAGE_OPEN_FAILED", WERR_INSTALL_PACKAGE_OPEN_FAILED },
+       { "WERR_INSTALL_PACKAGE_INVALID", WERR_INSTALL_PACKAGE_INVALID },
+       { "WERR_INSTALL_UI_FAILURE", WERR_INSTALL_UI_FAILURE },
+       { "WERR_INSTALL_LOG_FAILURE", WERR_INSTALL_LOG_FAILURE },
+       { "WERR_INSTALL_LANGUAGE_UNSUPPORTED", WERR_INSTALL_LANGUAGE_UNSUPPORTED },
+       { "WERR_INSTALL_TRANSFORM_FAILURE", WERR_INSTALL_TRANSFORM_FAILURE },
+       { "WERR_INSTALL_PACKAGE_REJECTED", WERR_INSTALL_PACKAGE_REJECTED },
+       { "WERR_FUNCTION_NOT_CALLED", WERR_FUNCTION_NOT_CALLED },
+       { "WERR_FUNCTION_FAILED", WERR_FUNCTION_FAILED },
+       { "WERR_INVALID_TABLE", WERR_INVALID_TABLE },
+       { "WERR_DATATYPE_MISMATCH", WERR_DATATYPE_MISMATCH },
+       { "WERR_UNSUPPORTED_TYPE", WERR_UNSUPPORTED_TYPE },
+       { "WERR_CREATE_FAILED", WERR_CREATE_FAILED },
+       { "WERR_INSTALL_TEMP_UNWRITABLE", WERR_INSTALL_TEMP_UNWRITABLE },
+       { "WERR_INSTALL_PLATFORM_UNSUPPORTED", WERR_INSTALL_PLATFORM_UNSUPPORTED },
+       { "WERR_INSTALL_NOTUSED", WERR_INSTALL_NOTUSED },
+       { "WERR_PATCH_PACKAGE_OPEN_FAILED", WERR_PATCH_PACKAGE_OPEN_FAILED },
+       { "WERR_PATCH_PACKAGE_INVALID", WERR_PATCH_PACKAGE_INVALID },
+       { "WERR_PATCH_PACKAGE_UNSUPPORTED", WERR_PATCH_PACKAGE_UNSUPPORTED },
+       { "WERR_PRODUCT_VERSION", WERR_PRODUCT_VERSION },
+       { "WERR_INVALID_COMMAND_LINE", WERR_INVALID_COMMAND_LINE },
+       { "WERR_INSTALL_REMOTE_DISALLOWED", WERR_INSTALL_REMOTE_DISALLOWED },
+       { "WERR_SUCCESS_REBOOT_INITIATED", WERR_SUCCESS_REBOOT_INITIATED },
+       { "WERR_PATCH_TARGET_NOT_FOUND", WERR_PATCH_TARGET_NOT_FOUND },
+       { "WERR_PATCH_PACKAGE_REJECTED", WERR_PATCH_PACKAGE_REJECTED },
+       { "WERR_INSTALL_TRANSFORM_REJECTED", WERR_INSTALL_TRANSFORM_REJECTED },
+       { "WERR_INSTALL_REMOTE_PROHIBITED", WERR_INSTALL_REMOTE_PROHIBITED },
+       { "WERR_PATCH_REMOVAL_UNSUPPORTED", WERR_PATCH_REMOVAL_UNSUPPORTED },
+       { "WERR_UNKNOWN_PATCH", WERR_UNKNOWN_PATCH },
+       { "WERR_PATCH_NO_SEQUENCE", WERR_PATCH_NO_SEQUENCE },
+       { "WERR_PATCH_REMOVAL_DISALLOWED", WERR_PATCH_REMOVAL_DISALLOWED },
+       { "WERR_INVALID_PATCH_XML", WERR_INVALID_PATCH_XML },
+       { "WERR_PATCH_MANAGED_ADVERTISED_PRODUCT", WERR_PATCH_MANAGED_ADVERTISED_PRODUCT },
+       { "WERR_INSTALL_SERVICE_SAFEBOOT", WERR_INSTALL_SERVICE_SAFEBOOT },
+       { "WERR_RPC_S_INVALID_STRING_BINDING", WERR_RPC_S_INVALID_STRING_BINDING },
+       { "WERR_RPC_S_WRONG_KIND_OF_BINDING", WERR_RPC_S_WRONG_KIND_OF_BINDING },
+       { "WERR_RPC_S_INVALID_BINDING", WERR_RPC_S_INVALID_BINDING },
+       { "WERR_RPC_S_PROTSEQ_NOT_SUPPORTED", WERR_RPC_S_PROTSEQ_NOT_SUPPORTED },
+       { "WERR_RPC_S_INVALID_RPC_PROTSEQ", WERR_RPC_S_INVALID_RPC_PROTSEQ },
+       { "WERR_RPC_S_INVALID_STRING_UUID", WERR_RPC_S_INVALID_STRING_UUID },
+       { "WERR_RPC_S_INVALID_ENDPOINT_FORMAT", WERR_RPC_S_INVALID_ENDPOINT_FORMAT },
+       { "WERR_RPC_S_INVALID_NET_ADDR", WERR_RPC_S_INVALID_NET_ADDR },
+       { "WERR_RPC_S_NO_ENDPOINT_FOUND", WERR_RPC_S_NO_ENDPOINT_FOUND },
+       { "WERR_RPC_S_INVALID_TIMEOUT", WERR_RPC_S_INVALID_TIMEOUT },
+       { "WERR_RPC_S_OBJECT_NOT_FOUND", WERR_RPC_S_OBJECT_NOT_FOUND },
+       { "WERR_RPC_S_ALREADY_REGISTERED", WERR_RPC_S_ALREADY_REGISTERED },
+       { "WERR_RPC_S_TYPE_ALREADY_REGISTERED", WERR_RPC_S_TYPE_ALREADY_REGISTERED },
+       { "WERR_RPC_S_ALREADY_LISTENING", WERR_RPC_S_ALREADY_LISTENING },
+       { "WERR_RPC_S_NO_PROTSEQS_REGISTERED", WERR_RPC_S_NO_PROTSEQS_REGISTERED },
+       { "WERR_RPC_S_NOT_LISTENING", WERR_RPC_S_NOT_LISTENING },
+       { "WERR_RPC_S_UNKNOWN_MGR_TYPE", WERR_RPC_S_UNKNOWN_MGR_TYPE },
+       { "WERR_RPC_S_UNKNOWN_IF", WERR_RPC_S_UNKNOWN_IF },
+       { "WERR_RPC_S_NO_BINDINGS", WERR_RPC_S_NO_BINDINGS },
+       { "WERR_RPC_S_NO_PROTSEQS", WERR_RPC_S_NO_PROTSEQS },
+       { "WERR_RPC_S_CANT_CREATE_ENDPOINT", WERR_RPC_S_CANT_CREATE_ENDPOINT },
+       { "WERR_RPC_S_OUT_OF_RESOURCES", WERR_RPC_S_OUT_OF_RESOURCES },
+       { "WERR_RPC_S_SERVER_UNAVAILABLE", WERR_RPC_S_SERVER_UNAVAILABLE },
+       { "WERR_RPC_S_SERVER_TOO_BUSY", WERR_RPC_S_SERVER_TOO_BUSY },
+       { "WERR_RPC_S_INVALID_NETWORK_OPTIONS", WERR_RPC_S_INVALID_NETWORK_OPTIONS },
+       { "WERR_RPC_S_NO_CALL_ACTIVE", WERR_RPC_S_NO_CALL_ACTIVE },
+       { "WERR_RPC_S_CALL_FAILED", WERR_RPC_S_CALL_FAILED },
+       { "WERR_RPC_S_CALL_FAILED_DNE", WERR_RPC_S_CALL_FAILED_DNE },
+       { "WERR_RPC_S_PROTOCOL_ERROR", WERR_RPC_S_PROTOCOL_ERROR },
+       { "WERR_RPC_S_PROXY_ACCESS_DENIED", WERR_RPC_S_PROXY_ACCESS_DENIED },
+       { "WERR_RPC_S_UNSUPPORTED_TRANS_SYN", WERR_RPC_S_UNSUPPORTED_TRANS_SYN },
+       { "WERR_RPC_S_UNSUPPORTED_TYPE", WERR_RPC_S_UNSUPPORTED_TYPE },
+       { "WERR_RPC_S_INVALID_TAG", WERR_RPC_S_INVALID_TAG },
+       { "WERR_RPC_S_INVALID_BOUND", WERR_RPC_S_INVALID_BOUND },
+       { "WERR_RPC_S_NO_ENTRY_NAME", WERR_RPC_S_NO_ENTRY_NAME },
+       { "WERR_RPC_S_INVALID_NAME_SYNTAX", WERR_RPC_S_INVALID_NAME_SYNTAX },
+       { "WERR_RPC_S_UNSUPPORTED_NAME_SYNTAX", WERR_RPC_S_UNSUPPORTED_NAME_SYNTAX },
+       { "WERR_RPC_S_UUID_NO_ADDRESS", WERR_RPC_S_UUID_NO_ADDRESS },
+       { "WERR_RPC_S_DUPLICATE_ENDPOINT", WERR_RPC_S_DUPLICATE_ENDPOINT },
+       { "WERR_RPC_S_UNKNOWN_AUTHN_TYPE", WERR_RPC_S_UNKNOWN_AUTHN_TYPE },
+       { "WERR_RPC_S_MAX_CALLS_TOO_SMALL", WERR_RPC_S_MAX_CALLS_TOO_SMALL },
+       { "WERR_RPC_S_STRING_TOO_LONG", WERR_RPC_S_STRING_TOO_LONG },
+       { "WERR_RPC_S_PROTSEQ_NOT_FOUND", WERR_RPC_S_PROTSEQ_NOT_FOUND },
+       { "WERR_RPC_S_PROCNUM_OUT_OF_RANGE", WERR_RPC_S_PROCNUM_OUT_OF_RANGE },
+       { "WERR_RPC_S_BINDING_HAS_NO_AUTH", WERR_RPC_S_BINDING_HAS_NO_AUTH },
+       { "WERR_RPC_S_UNKNOWN_AUTHN_SERVICE", WERR_RPC_S_UNKNOWN_AUTHN_SERVICE },
+       { "WERR_RPC_S_UNKNOWN_AUTHN_LEVEL", WERR_RPC_S_UNKNOWN_AUTHN_LEVEL },
+       { "WERR_RPC_S_INVALID_AUTH_IDENTITY", WERR_RPC_S_INVALID_AUTH_IDENTITY },
+       { "WERR_RPC_S_UNKNOWN_AUTHZ_SERVICE", WERR_RPC_S_UNKNOWN_AUTHZ_SERVICE },
+       { "WERR_EPT_S_INVALID_ENTRY", WERR_EPT_S_INVALID_ENTRY },
+       { "WERR_EPT_S_CANT_PERFORM_OP", WERR_EPT_S_CANT_PERFORM_OP },
+       { "WERR_EPT_S_NOT_REGISTERED", WERR_EPT_S_NOT_REGISTERED },
+       { "WERR_RPC_S_NOTHING_TO_EXPORT", WERR_RPC_S_NOTHING_TO_EXPORT },
+       { "WERR_RPC_S_INCOMPLETE_NAME", WERR_RPC_S_INCOMPLETE_NAME },
+       { "WERR_RPC_S_INVALID_VERS_OPTION", WERR_RPC_S_INVALID_VERS_OPTION },
+       { "WERR_RPC_S_NO_MORE_MEMBERS", WERR_RPC_S_NO_MORE_MEMBERS },
+       { "WERR_RPC_S_NOT_ALL_OBJS_UNEXPORTED", WERR_RPC_S_NOT_ALL_OBJS_UNEXPORTED },
+       { "WERR_RPC_S_INTERFACE_NOT_FOUND", WERR_RPC_S_INTERFACE_NOT_FOUND },
+       { "WERR_RPC_S_ENTRY_ALREADY_EXISTS", WERR_RPC_S_ENTRY_ALREADY_EXISTS },
+       { "WERR_RPC_S_ENTRY_NOT_FOUND", WERR_RPC_S_ENTRY_NOT_FOUND },
+       { "WERR_RPC_S_NAME_SERVICE_UNAVAILABLE", WERR_RPC_S_NAME_SERVICE_UNAVAILABLE },
+       { "WERR_RPC_S_INVALID_NAF_ID", WERR_RPC_S_INVALID_NAF_ID },
+       { "WERR_RPC_S_CANNOT_SUPPORT", WERR_RPC_S_CANNOT_SUPPORT },
+       { "WERR_RPC_S_NO_CONTEXT_AVAILABLE", WERR_RPC_S_NO_CONTEXT_AVAILABLE },
+       { "WERR_RPC_S_INTERNAL_ERROR", WERR_RPC_S_INTERNAL_ERROR },
+       { "WERR_RPC_S_ZERO_DIVIDE", WERR_RPC_S_ZERO_DIVIDE },
+       { "WERR_RPC_S_ADDRESS_ERROR", WERR_RPC_S_ADDRESS_ERROR },
+       { "WERR_RPC_S_FP_DIV_ZERO", WERR_RPC_S_FP_DIV_ZERO },
+       { "WERR_RPC_S_FP_UNDERFLOW", WERR_RPC_S_FP_UNDERFLOW },
+       { "WERR_RPC_S_FP_OVERFLOW", WERR_RPC_S_FP_OVERFLOW },
+       { "WERR_RPC_X_NO_MORE_ENTRIES", WERR_RPC_X_NO_MORE_ENTRIES },
+       { "WERR_RPC_X_SS_CHAR_TRANS_OPEN_FAIL", WERR_RPC_X_SS_CHAR_TRANS_OPEN_FAIL },
+       { "WERR_RPC_X_SS_CHAR_TRANS_SHORT_FILE", WERR_RPC_X_SS_CHAR_TRANS_SHORT_FILE },
+       { "WERR_RPC_X_SS_IN_NULL_CONTEXT", WERR_RPC_X_SS_IN_NULL_CONTEXT },
+       { "WERR_RPC_X_SS_CONTEXT_DAMAGED", WERR_RPC_X_SS_CONTEXT_DAMAGED },
+       { "WERR_RPC_X_SS_HANDLES_MISMATCH", WERR_RPC_X_SS_HANDLES_MISMATCH },
+       { "WERR_RPC_X_SS_CANNOT_GET_CALL_HANDLE", WERR_RPC_X_SS_CANNOT_GET_CALL_HANDLE },
+       { "WERR_RPC_X_NULL_REF_POINTER", WERR_RPC_X_NULL_REF_POINTER },
+       { "WERR_RPC_X_ENUM_VALUE_OUT_OF_RANGE", WERR_RPC_X_ENUM_VALUE_OUT_OF_RANGE },
+       { "WERR_RPC_X_BYTE_COUNT_TOO_SMALL", WERR_RPC_X_BYTE_COUNT_TOO_SMALL },
+       { "WERR_RPC_X_BAD_STUB_DATA", WERR_RPC_X_BAD_STUB_DATA },
+       { "WERR_UNRECOGNIZED_MEDIA", WERR_UNRECOGNIZED_MEDIA },
+       { "WERR_NO_TRUST_LSA_SECRET", WERR_NO_TRUST_LSA_SECRET },
+       { "WERR_TRUSTED_DOMAIN_FAILURE", WERR_TRUSTED_DOMAIN_FAILURE },
+       { "WERR_TRUSTED_RELATIONSHIP_FAILURE", WERR_TRUSTED_RELATIONSHIP_FAILURE },
+       { "WERR_TRUST_FAILURE", WERR_TRUST_FAILURE },
+       { "WERR_RPC_S_CALL_IN_PROGRESS", WERR_RPC_S_CALL_IN_PROGRESS },
+       { "WERR_NETLOGON_NOT_STARTED", WERR_NETLOGON_NOT_STARTED },
+       { "WERR_ACCOUNT_EXPIRED", WERR_ACCOUNT_EXPIRED },
+       { "WERR_REDIRECTOR_HAS_OPEN_HANDLES", WERR_REDIRECTOR_HAS_OPEN_HANDLES },
+       { "WERR_RPC_S_NO_MORE_BINDINGS", WERR_RPC_S_NO_MORE_BINDINGS },
+       { "WERR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT", WERR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT },
+       { "WERR_NOLOGON_WORKSTATION_TRUST_ACCOUNT", WERR_NOLOGON_WORKSTATION_TRUST_ACCOUNT },
+       { "WERR_NOLOGON_SERVER_TRUST_ACCOUNT", WERR_NOLOGON_SERVER_TRUST_ACCOUNT },
+       { "WERR_DOMAIN_TRUST_INCONSISTENT", WERR_DOMAIN_TRUST_INCONSISTENT },
+       { "WERR_SERVER_HAS_OPEN_HANDLES", WERR_SERVER_HAS_OPEN_HANDLES },
+       { "WERR_RESOURCE_DATA_NOT_FOUND", WERR_RESOURCE_DATA_NOT_FOUND },
+       { "WERR_RESOURCE_TYPE_NOT_FOUND", WERR_RESOURCE_TYPE_NOT_FOUND },
+       { "WERR_RESOURCE_NAME_NOT_FOUND", WERR_RESOURCE_NAME_NOT_FOUND },
+       { "WERR_RESOURCE_LANG_NOT_FOUND", WERR_RESOURCE_LANG_NOT_FOUND },
+       { "WERR_NOT_ENOUGH_QUOTA", WERR_NOT_ENOUGH_QUOTA },
+       { "WERR_RPC_S_NO_INTERFACES", WERR_RPC_S_NO_INTERFACES },
+       { "WERR_RPC_S_CALL_CANCELLED", WERR_RPC_S_CALL_CANCELLED },
+       { "WERR_RPC_S_BINDING_INCOMPLETE", WERR_RPC_S_BINDING_INCOMPLETE },
+       { "WERR_RPC_S_COMM_FAILURE", WERR_RPC_S_COMM_FAILURE },
+       { "WERR_RPC_S_UNSUPPORTED_AUTHN_LEVEL", WERR_RPC_S_UNSUPPORTED_AUTHN_LEVEL },
+       { "WERR_RPC_S_NO_PRINC_NAME", WERR_RPC_S_NO_PRINC_NAME },
+       { "WERR_RPC_S_NOT_RPC_ERROR", WERR_RPC_S_NOT_RPC_ERROR },
+       { "WERR_RPC_S_UUID_LOCAL_ONLY", WERR_RPC_S_UUID_LOCAL_ONLY },
+       { "WERR_RPC_S_SEC_PKG_ERROR", WERR_RPC_S_SEC_PKG_ERROR },
+       { "WERR_RPC_S_NOT_CANCELLED", WERR_RPC_S_NOT_CANCELLED },
+       { "WERR_RPC_X_INVALID_ES_ACTION", WERR_RPC_X_INVALID_ES_ACTION },
+       { "WERR_RPC_X_WRONG_ES_VERSION", WERR_RPC_X_WRONG_ES_VERSION },
+       { "WERR_RPC_X_WRONG_STUB_VERSION", WERR_RPC_X_WRONG_STUB_VERSION },
+       { "WERR_RPC_X_INVALID_PIPE_OBJECT", WERR_RPC_X_INVALID_PIPE_OBJECT },
+       { "WERR_RPC_X_WRONG_PIPE_ORDER", WERR_RPC_X_WRONG_PIPE_ORDER },
+       { "WERR_RPC_X_WRONG_PIPE_VERSION", WERR_RPC_X_WRONG_PIPE_VERSION },
+       { "WERR_RPC_S_GROUP_MEMBER_NOT_FOUND", WERR_RPC_S_GROUP_MEMBER_NOT_FOUND },
+       { "WERR_EPT_S_CANT_CREATE", WERR_EPT_S_CANT_CREATE },
+       { "WERR_RPC_S_INVALID_OBJECT", WERR_RPC_S_INVALID_OBJECT },
+       { "WERR_INVALID_TIME", WERR_INVALID_TIME },
+       { "WERR_ALREADY_WAITING", WERR_ALREADY_WAITING },
+       { "WERR_PRINTER_DELETED", WERR_PRINTER_DELETED },
+       { "WERR_INVALID_PRINTER_STATE", WERR_INVALID_PRINTER_STATE },
+       { "WERR_OR_INVALID_OXID", WERR_OR_INVALID_OXID },
+       { "WERR_OR_INVALID_OID", WERR_OR_INVALID_OID },
+       { "WERR_OR_INVALID_SET", WERR_OR_INVALID_SET },
+       { "WERR_RPC_S_SEND_INCOMPLETE", WERR_RPC_S_SEND_INCOMPLETE },
+       { "WERR_RPC_S_INVALID_ASYNC_HANDLE", WERR_RPC_S_INVALID_ASYNC_HANDLE },
+       { "WERR_RPC_S_INVALID_ASYNC_CALL", WERR_RPC_S_INVALID_ASYNC_CALL },
+       { "WERR_RPC_X_PIPE_CLOSED", WERR_RPC_X_PIPE_CLOSED },
+       { "WERR_RPC_X_PIPE_DISCIPLINE_ERROR", WERR_RPC_X_PIPE_DISCIPLINE_ERROR },
+       { "WERR_RPC_X_PIPE_EMPTY", WERR_RPC_X_PIPE_EMPTY },
+       { "WERR_NO_SITENAME", WERR_NO_SITENAME },
+       { "WERR_CANT_ACCESS_FILE", WERR_CANT_ACCESS_FILE },
+       { "WERR_CANT_RESOLVE_FILENAME", WERR_CANT_RESOLVE_FILENAME },
+       { "WERR_RPC_S_ENTRY_TYPE_MISMATCH", WERR_RPC_S_ENTRY_TYPE_MISMATCH },
+       { "WERR_RPC_S_NOT_ALL_OBJS_EXPORTED", WERR_RPC_S_NOT_ALL_OBJS_EXPORTED },
+       { "WERR_RPC_S_INTERFACE_NOT_EXPORTED", WERR_RPC_S_INTERFACE_NOT_EXPORTED },
+       { "WERR_RPC_S_PROFILE_NOT_ADDED", WERR_RPC_S_PROFILE_NOT_ADDED },
+       { "WERR_RPC_S_PRF_ELT_NOT_ADDED", WERR_RPC_S_PRF_ELT_NOT_ADDED },
+       { "WERR_RPC_S_PRF_ELT_NOT_REMOVED", WERR_RPC_S_PRF_ELT_NOT_REMOVED },
+       { "WERR_RPC_S_GRP_ELT_NOT_ADDED", WERR_RPC_S_GRP_ELT_NOT_ADDED },
+       { "WERR_RPC_S_GRP_ELT_NOT_REMOVED", WERR_RPC_S_GRP_ELT_NOT_REMOVED },
+       { "WERR_KM_DRIVER_BLOCKED", WERR_KM_DRIVER_BLOCKED },
+       { "WERR_CONTEXT_EXPIRED", WERR_CONTEXT_EXPIRED },
+       { "WERR_PER_USER_TRUST_QUOTA_EXCEEDED", WERR_PER_USER_TRUST_QUOTA_EXCEEDED },
+       { "WERR_ALL_USER_TRUST_QUOTA_EXCEEDED", WERR_ALL_USER_TRUST_QUOTA_EXCEEDED },
+       { "WERR_USER_DELETE_TRUST_QUOTA_EXCEEDED", WERR_USER_DELETE_TRUST_QUOTA_EXCEEDED },
+       { "WERR_AUTHENTICATION_FIREWALL_FAILED", WERR_AUTHENTICATION_FIREWALL_FAILED },
+       { "WERR_REMOTE_PRINT_CONNECTIONS_BLOCKED", WERR_REMOTE_PRINT_CONNECTIONS_BLOCKED },
+       { "WERR_INVALID_PIXEL_FORMAT", WERR_INVALID_PIXEL_FORMAT },
+       { "WERR_BAD_DRIVER", WERR_BAD_DRIVER },
+       { "WERR_INVALID_WINDOW_STYLE", WERR_INVALID_WINDOW_STYLE },
+       { "WERR_METAFILE_NOT_SUPPORTED", WERR_METAFILE_NOT_SUPPORTED },
+       { "WERR_TRANSFORM_NOT_SUPPORTED", WERR_TRANSFORM_NOT_SUPPORTED },
+       { "WERR_CLIPPING_NOT_SUPPORTED", WERR_CLIPPING_NOT_SUPPORTED },
+       { "WERR_INVALID_CMM", WERR_INVALID_CMM },
+       { "WERR_INVALID_PROFILE", WERR_INVALID_PROFILE },
+       { "WERR_TAG_NOT_FOUND", WERR_TAG_NOT_FOUND },
+       { "WERR_TAG_NOT_PRESENT", WERR_TAG_NOT_PRESENT },
+       { "WERR_DUPLICATE_TAG", WERR_DUPLICATE_TAG },
+       { "WERR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE", WERR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE },
+       { "WERR_PROFILE_NOT_FOUND", WERR_PROFILE_NOT_FOUND },
+       { "WERR_INVALID_COLORSPACE", WERR_INVALID_COLORSPACE },
+       { "WERR_ICM_NOT_ENABLED", WERR_ICM_NOT_ENABLED },
+       { "WERR_DELETING_ICM_XFORM", WERR_DELETING_ICM_XFORM },
+       { "WERR_INVALID_TRANSFORM", WERR_INVALID_TRANSFORM },
+       { "WERR_COLORSPACE_MISMATCH", WERR_COLORSPACE_MISMATCH },
+       { "WERR_INVALID_COLORINDEX", WERR_INVALID_COLORINDEX },
+       { "WERR_PROFILE_DOES_NOT_MATCH_DEVICE", WERR_PROFILE_DOES_NOT_MATCH_DEVICE },
+       { "WERR_NERR_NETNOTSTARTED", WERR_NERR_NETNOTSTARTED },
+       { "WERR_NERR_UNKNOWNSERVER", WERR_NERR_UNKNOWNSERVER },
+       { "WERR_NERR_SHAREMEM", WERR_NERR_SHAREMEM },
+       { "WERR_NERR_NONETWORKRESOURCE", WERR_NERR_NONETWORKRESOURCE },
+       { "WERR_NERR_REMOTEONLY", WERR_NERR_REMOTEONLY },
+       { "WERR_NERR_DEVNOTREDIRECTED", WERR_NERR_DEVNOTREDIRECTED },
+       { "WERR_CONNECTED_OTHER_PASSWORD", WERR_CONNECTED_OTHER_PASSWORD },
+       { "WERR_CONNECTED_OTHER_PASSWORD_DEFAULT", WERR_CONNECTED_OTHER_PASSWORD_DEFAULT },
+       { "WERR_NERR_SERVERNOTSTARTED", WERR_NERR_SERVERNOTSTARTED },
+       { "WERR_NERR_ITEMNOTFOUND", WERR_NERR_ITEMNOTFOUND },
+       { "WERR_NERR_UNKNOWNDEVDIR", WERR_NERR_UNKNOWNDEVDIR },
+       { "WERR_NERR_REDIRECTEDPATH", WERR_NERR_REDIRECTEDPATH },
+       { "WERR_NERR_DUPLICATESHARE", WERR_NERR_DUPLICATESHARE },
+       { "WERR_NERR_NOROOM", WERR_NERR_NOROOM },
+       { "WERR_NERR_TOOMANYITEMS", WERR_NERR_TOOMANYITEMS },
+       { "WERR_NERR_INVALIDMAXUSERS", WERR_NERR_INVALIDMAXUSERS },
+       { "WERR_NERR_BUFTOOSMALL", WERR_NERR_BUFTOOSMALL },
+       { "WERR_NERR_REMOTEERR", WERR_NERR_REMOTEERR },
+       { "WERR_NERR_LANMANINIERROR", WERR_NERR_LANMANINIERROR },
+       { "WERR_NERR_NETWORKERROR", WERR_NERR_NETWORKERROR },
+       { "WERR_NERR_WKSTAINCONSISTENTSTATE", WERR_NERR_WKSTAINCONSISTENTSTATE },
+       { "WERR_NERR_WKSTANOTSTARTED", WERR_NERR_WKSTANOTSTARTED },
+       { "WERR_NERR_BROWSERNOTSTARTED", WERR_NERR_BROWSERNOTSTARTED },
+       { "WERR_NERR_INTERNALERROR", WERR_NERR_INTERNALERROR },
+       { "WERR_NERR_BADTRANSACTCONFIG", WERR_NERR_BADTRANSACTCONFIG },
+       { "WERR_NERR_INVALIDAPI", WERR_NERR_INVALIDAPI },
+       { "WERR_NERR_BADEVENTNAME", WERR_NERR_BADEVENTNAME },
+       { "WERR_NERR_DUPNAMEREBOOT", WERR_NERR_DUPNAMEREBOOT },
+       { "WERR_NERR_CFGCOMPNOTFOUND", WERR_NERR_CFGCOMPNOTFOUND },
+       { "WERR_NERR_CFGPARAMNOTFOUND", WERR_NERR_CFGPARAMNOTFOUND },
+       { "WERR_NERR_LINETOOLONG", WERR_NERR_LINETOOLONG },
+       { "WERR_NERR_QNOTFOUND", WERR_NERR_QNOTFOUND },
+       { "WERR_NERR_JOBNOTFOUND", WERR_NERR_JOBNOTFOUND },
+       { "WERR_NERR_DESTNOTFOUND", WERR_NERR_DESTNOTFOUND },
+       { "WERR_NERR_DESTEXISTS", WERR_NERR_DESTEXISTS },
+       { "WERR_NERR_QEXISTS", WERR_NERR_QEXISTS },
+       { "WERR_NERR_QNOROOM", WERR_NERR_QNOROOM },
+       { "WERR_NERR_JOBNOROOM", WERR_NERR_JOBNOROOM },
+       { "WERR_NERR_DESTNOROOM", WERR_NERR_DESTNOROOM },
+       { "WERR_NERR_DESTIDLE", WERR_NERR_DESTIDLE },
+       { "WERR_NERR_DESTINVALIDOP", WERR_NERR_DESTINVALIDOP },
+       { "WERR_NERR_PROCNORESPOND", WERR_NERR_PROCNORESPOND },
+       { "WERR_NERR_SPOOLERNOTLOADED", WERR_NERR_SPOOLERNOTLOADED },
+       { "WERR_NERR_DESTINVALIDSTATE", WERR_NERR_DESTINVALIDSTATE },
+       { "WERR_NERR_QINVALIDSTATE", WERR_NERR_QINVALIDSTATE },
+       { "WERR_NERR_JOBINVALIDSTATE", WERR_NERR_JOBINVALIDSTATE },
+       { "WERR_NERR_SPOOLNOMEMORY", WERR_NERR_SPOOLNOMEMORY },
+       { "WERR_NERR_DRIVERNOTFOUND", WERR_NERR_DRIVERNOTFOUND },
+       { "WERR_NERR_DATATYPEINVALID", WERR_NERR_DATATYPEINVALID },
+       { "WERR_NERR_PROCNOTFOUND", WERR_NERR_PROCNOTFOUND },
+       { "WERR_NERR_SERVICETABLELOCKED", WERR_NERR_SERVICETABLELOCKED },
+       { "WERR_NERR_SERVICETABLEFULL", WERR_NERR_SERVICETABLEFULL },
+       { "WERR_NERR_SERVICEINSTALLED", WERR_NERR_SERVICEINSTALLED },
+       { "WERR_NERR_SERVICEENTRYLOCKED", WERR_NERR_SERVICEENTRYLOCKED },
+       { "WERR_NERR_SERVICENOTINSTALLED", WERR_NERR_SERVICENOTINSTALLED },
+       { "WERR_NERR_BADSERVICENAME", WERR_NERR_BADSERVICENAME },
+       { "WERR_NERR_SERVICECTLTIMEOUT", WERR_NERR_SERVICECTLTIMEOUT },
+       { "WERR_NERR_SERVICECTLBUSY", WERR_NERR_SERVICECTLBUSY },
+       { "WERR_NERR_BADSERVICEPROGNAME", WERR_NERR_BADSERVICEPROGNAME },
+       { "WERR_NERR_SERVICENOTCTRL", WERR_NERR_SERVICENOTCTRL },
+       { "WERR_NERR_SERVICEKILLPROC", WERR_NERR_SERVICEKILLPROC },
+       { "WERR_NERR_SERVICECTLNOTVALID", WERR_NERR_SERVICECTLNOTVALID },
+       { "WERR_NERR_NOTINDISPATCHTBL", WERR_NERR_NOTINDISPATCHTBL },
+       { "WERR_NERR_BADCONTROLRECV", WERR_NERR_BADCONTROLRECV },
+       { "WERR_NERR_SERVICENOTSTARTING", WERR_NERR_SERVICENOTSTARTING },
+       { "WERR_NERR_ALREADYLOGGEDON", WERR_NERR_ALREADYLOGGEDON },
+       { "WERR_NERR_NOTLOGGEDON", WERR_NERR_NOTLOGGEDON },
+       { "WERR_NERR_BADUSERNAME", WERR_NERR_BADUSERNAME },
+       { "WERR_NERR_BADPASSWORD", WERR_NERR_BADPASSWORD },
+       { "WERR_NERR_UNABLETOADDNAME_W", WERR_NERR_UNABLETOADDNAME_W },
+       { "WERR_NERR_UNABLETOADDNAME_F", WERR_NERR_UNABLETOADDNAME_F },
+       { "WERR_NERR_UNABLETODELNAME_W", WERR_NERR_UNABLETODELNAME_W },
+       { "WERR_NERR_UNABLETODELNAME_F", WERR_NERR_UNABLETODELNAME_F },
+       { "WERR_NERR_LOGONSPAUSED", WERR_NERR_LOGONSPAUSED },
+       { "WERR_NERR_LOGONSERVERCONFLICT", WERR_NERR_LOGONSERVERCONFLICT },
+       { "WERR_NERR_LOGONNOUSERPATH", WERR_NERR_LOGONNOUSERPATH },
+       { "WERR_NERR_LOGONSCRIPTERROR", WERR_NERR_LOGONSCRIPTERROR },
+       { "WERR_NERR_STANDALONELOGON", WERR_NERR_STANDALONELOGON },
+       { "WERR_NERR_LOGONSERVERNOTFOUND", WERR_NERR_LOGONSERVERNOTFOUND },
+       { "WERR_NERR_LOGONDOMAINEXISTS", WERR_NERR_LOGONDOMAINEXISTS },
+       { "WERR_NERR_NONVALIDATEDLOGON", WERR_NERR_NONVALIDATEDLOGON },
+       { "WERR_NERR_ACFNOTFOUND", WERR_NERR_ACFNOTFOUND },
+       { "WERR_NERR_GROUPNOTFOUND", WERR_NERR_GROUPNOTFOUND },
+       { "WERR_NERR_USERNOTFOUND", WERR_NERR_USERNOTFOUND },
+       { "WERR_NERR_RESOURCENOTFOUND", WERR_NERR_RESOURCENOTFOUND },
+       { "WERR_NERR_GROUPEXISTS", WERR_NERR_GROUPEXISTS },
+       { "WERR_NERR_USEREXISTS", WERR_NERR_USEREXISTS },
+       { "WERR_NERR_RESOURCEEXISTS", WERR_NERR_RESOURCEEXISTS },
+       { "WERR_NERR_NOTPRIMARY", WERR_NERR_NOTPRIMARY },
+       { "WERR_NERR_ACFNOTLOADED", WERR_NERR_ACFNOTLOADED },
+       { "WERR_NERR_ACFNOROOM", WERR_NERR_ACFNOROOM },
+       { "WERR_NERR_ACFFILEIOFAIL", WERR_NERR_ACFFILEIOFAIL },
+       { "WERR_NERR_ACFTOOMANYLISTS", WERR_NERR_ACFTOOMANYLISTS },
+       { "WERR_NERR_USERLOGON", WERR_NERR_USERLOGON },
+       { "WERR_NERR_ACFNOPARENT", WERR_NERR_ACFNOPARENT },
+       { "WERR_NERR_CANNOTGROWSEGMENT", WERR_NERR_CANNOTGROWSEGMENT },
+       { "WERR_NERR_SPEGROUPOP", WERR_NERR_SPEGROUPOP },
+       { "WERR_NERR_NOTINCACHE", WERR_NERR_NOTINCACHE },
+       { "WERR_NERR_USERINGROUP", WERR_NERR_USERINGROUP },
+       { "WERR_NERR_USERNOTINGROUP", WERR_NERR_USERNOTINGROUP },
+       { "WERR_NERR_ACCOUNTUNDEFINED", WERR_NERR_ACCOUNTUNDEFINED },
+       { "WERR_NERR_ACCOUNTEXPIRED", WERR_NERR_ACCOUNTEXPIRED },
+       { "WERR_NERR_INVALIDWORKSTATION", WERR_NERR_INVALIDWORKSTATION },
+       { "WERR_NERR_INVALIDLOGONHOURS", WERR_NERR_INVALIDLOGONHOURS },
+       { "WERR_NERR_PASSWORDEXPIRED", WERR_NERR_PASSWORDEXPIRED },
+       { "WERR_NERR_PASSWORDCANTCHANGE", WERR_NERR_PASSWORDCANTCHANGE },
+       { "WERR_NERR_PASSWORDHISTCONFLICT", WERR_NERR_PASSWORDHISTCONFLICT },
+       { "WERR_NERR_PASSWORDTOOSHORT", WERR_NERR_PASSWORDTOOSHORT },
+       { "WERR_NERR_PASSWORDTOORECENT", WERR_NERR_PASSWORDTOORECENT },
+       { "WERR_NERR_INVALIDDATABASE", WERR_NERR_INVALIDDATABASE },
+       { "WERR_NERR_DATABASEUPTODATE", WERR_NERR_DATABASEUPTODATE },
+       { "WERR_NERR_SYNCREQUIRED", WERR_NERR_SYNCREQUIRED },
+       { "WERR_NERR_USENOTFOUND", WERR_NERR_USENOTFOUND },
+       { "WERR_NERR_BADASGTYPE", WERR_NERR_BADASGTYPE },
+       { "WERR_NERR_DEVICEISSHARED", WERR_NERR_DEVICEISSHARED },
+       { "WERR_NERR_NOCOMPUTERNAME", WERR_NERR_NOCOMPUTERNAME },
+       { "WERR_NERR_MSGALREADYSTARTED", WERR_NERR_MSGALREADYSTARTED },
+       { "WERR_NERR_MSGINITFAILED", WERR_NERR_MSGINITFAILED },
+       { "WERR_NERR_NAMENOTFOUND", WERR_NERR_NAMENOTFOUND },
+       { "WERR_NERR_ALREADYFORWARDED", WERR_NERR_ALREADYFORWARDED },
+       { "WERR_NERR_ADDFORWARDED", WERR_NERR_ADDFORWARDED },
+       { "WERR_NERR_ALREADYEXISTS", WERR_NERR_ALREADYEXISTS },
+       { "WERR_NERR_TOOMANYNAMES", WERR_NERR_TOOMANYNAMES },
+       { "WERR_NERR_DELCOMPUTERNAME", WERR_NERR_DELCOMPUTERNAME },
+       { "WERR_NERR_LOCALFORWARD", WERR_NERR_LOCALFORWARD },
+       { "WERR_NERR_GRPMSGPROCESSOR", WERR_NERR_GRPMSGPROCESSOR },
+       { "WERR_NERR_PAUSEDREMOTE", WERR_NERR_PAUSEDREMOTE },
+       { "WERR_NERR_BADRECEIVE", WERR_NERR_BADRECEIVE },
+       { "WERR_NERR_NAMEINUSE", WERR_NERR_NAMEINUSE },
+       { "WERR_NERR_MSGNOTSTARTED", WERR_NERR_MSGNOTSTARTED },
+       { "WERR_NERR_NOTLOCALNAME", WERR_NERR_NOTLOCALNAME },
+       { "WERR_NERR_NOFORWARDNAME", WERR_NERR_NOFORWARDNAME },
+       { "WERR_NERR_REMOTEFULL", WERR_NERR_REMOTEFULL },
+       { "WERR_NERR_NAMENOTFORWARDED", WERR_NERR_NAMENOTFORWARDED },
+       { "WERR_NERR_TRUNCATEDBROADCAST", WERR_NERR_TRUNCATEDBROADCAST },
+       { "WERR_NERR_INVALIDDEVICE", WERR_NERR_INVALIDDEVICE },
+       { "WERR_NERR_WRITEFAULT", WERR_NERR_WRITEFAULT },
+       { "WERR_NERR_DUPLICATENAME", WERR_NERR_DUPLICATENAME },
+       { "WERR_NERR_DELETELATER", WERR_NERR_DELETELATER },
+       { "WERR_NERR_INCOMPLETEDEL", WERR_NERR_INCOMPLETEDEL },
+       { "WERR_NERR_MULTIPLENETS", WERR_NERR_MULTIPLENETS },
+       { "WERR_NERR_NETNAMENOTFOUND", WERR_NERR_NETNAMENOTFOUND },
+       { "WERR_NERR_DEVICENOTSHARED", WERR_NERR_DEVICENOTSHARED },
+       { "WERR_NERR_CLIENTNAMENOTFOUND", WERR_NERR_CLIENTNAMENOTFOUND },
+       { "WERR_NERR_FILEIDNOTFOUND", WERR_NERR_FILEIDNOTFOUND },
+       { "WERR_NERR_EXECFAILURE", WERR_NERR_EXECFAILURE },
+       { "WERR_NERR_TMPFILE", WERR_NERR_TMPFILE },
+       { "WERR_NERR_TOOMUCHDATA", WERR_NERR_TOOMUCHDATA },
+       { "WERR_NERR_DEVICESHARECONFLICT", WERR_NERR_DEVICESHARECONFLICT },
+       { "WERR_NERR_BROWSERTABLEINCOMPLETE", WERR_NERR_BROWSERTABLEINCOMPLETE },
+       { "WERR_NERR_NOTLOCALDOMAIN", WERR_NERR_NOTLOCALDOMAIN },
+       { "WERR_NERR_ISDFSSHARE", WERR_NERR_ISDFSSHARE },
+       { "WERR_NERR_DEVINVALIDOPCODE", WERR_NERR_DEVINVALIDOPCODE },
+       { "WERR_NERR_DEVNOTFOUND", WERR_NERR_DEVNOTFOUND },
+       { "WERR_NERR_DEVNOTOPEN", WERR_NERR_DEVNOTOPEN },
+       { "WERR_NERR_BADQUEUEDEVSTRING", WERR_NERR_BADQUEUEDEVSTRING },
+       { "WERR_NERR_BADQUEUEPRIORITY", WERR_NERR_BADQUEUEPRIORITY },
+       { "WERR_NERR_NOCOMMDEVS", WERR_NERR_NOCOMMDEVS },
+       { "WERR_NERR_QUEUENOTFOUND", WERR_NERR_QUEUENOTFOUND },
+       { "WERR_NERR_BADDEVSTRING", WERR_NERR_BADDEVSTRING },
+       { "WERR_NERR_BADDEV", WERR_NERR_BADDEV },
+       { "WERR_NERR_INUSEBYSPOOLER", WERR_NERR_INUSEBYSPOOLER },
+       { "WERR_NERR_COMMDEVINUSE", WERR_NERR_COMMDEVINUSE },
+       { "WERR_NERR_INVALIDCOMPUTER", WERR_NERR_INVALIDCOMPUTER },
+       { "WERR_NERR_MAXLENEXCEEDED", WERR_NERR_MAXLENEXCEEDED },
+       { "WERR_NERR_BADCOMPONENT", WERR_NERR_BADCOMPONENT },
+       { "WERR_NERR_CANTTYPE", WERR_NERR_CANTTYPE },
+       { "WERR_NERR_TOOMANYENTRIES", WERR_NERR_TOOMANYENTRIES },
+       { "WERR_NERR_PROFILEFILETOOBIG", WERR_NERR_PROFILEFILETOOBIG },
+       { "WERR_NERR_PROFILEOFFSET", WERR_NERR_PROFILEOFFSET },
+       { "WERR_NERR_PROFILECLEANUP", WERR_NERR_PROFILECLEANUP },
+       { "WERR_NERR_PROFILEUNKNOWNCMD", WERR_NERR_PROFILEUNKNOWNCMD },
+       { "WERR_NERR_PROFILELOADERR", WERR_NERR_PROFILELOADERR },
+       { "WERR_NERR_PROFILESAVEERR", WERR_NERR_PROFILESAVEERR },
+       { "WERR_NERR_LOGOVERFLOW", WERR_NERR_LOGOVERFLOW },
+       { "WERR_NERR_LOGFILECHANGED", WERR_NERR_LOGFILECHANGED },
+       { "WERR_NERR_LOGFILECORRUPT", WERR_NERR_LOGFILECORRUPT },
+       { "WERR_NERR_SOURCEISDIR", WERR_NERR_SOURCEISDIR },
+       { "WERR_NERR_BADSOURCE", WERR_NERR_BADSOURCE },
+       { "WERR_NERR_BADDEST", WERR_NERR_BADDEST },
+       { "WERR_NERR_DIFFERENTSERVERS", WERR_NERR_DIFFERENTSERVERS },
+       { "WERR_NERR_RUNSRVPAUSED", WERR_NERR_RUNSRVPAUSED },
+       { "WERR_NERR_ERRCOMMRUNSRV", WERR_NERR_ERRCOMMRUNSRV },
+       { "WERR_NERR_ERROREXECINGGHOST", WERR_NERR_ERROREXECINGGHOST },
+       { "WERR_NERR_SHARENOTFOUND", WERR_NERR_SHARENOTFOUND },
+       { "WERR_NERR_INVALIDLANA", WERR_NERR_INVALIDLANA },
+       { "WERR_NERR_OPENFILES", WERR_NERR_OPENFILES },
+       { "WERR_NERR_ACTIVECONNS", WERR_NERR_ACTIVECONNS },
+       { "WERR_NERR_BADPASSWORDCORE", WERR_NERR_BADPASSWORDCORE },
+       { "WERR_NERR_DEVINUSE", WERR_NERR_DEVINUSE },
+       { "WERR_NERR_LOCALDRIVE", WERR_NERR_LOCALDRIVE },
+       { "WERR_NERR_ALERTEXISTS", WERR_NERR_ALERTEXISTS },
+       { "WERR_NERR_TOOMANYALERTS", WERR_NERR_TOOMANYALERTS },
+       { "WERR_NERR_NOSUCHALERT", WERR_NERR_NOSUCHALERT },
+       { "WERR_NERR_BADRECIPIENT", WERR_NERR_BADRECIPIENT },
+       { "WERR_NERR_ACCTLIMITEXCEEDED", WERR_NERR_ACCTLIMITEXCEEDED },
+       { "WERR_NERR_INVALIDLOGSEEK", WERR_NERR_INVALIDLOGSEEK },
+       { "WERR_NERR_BADUASCONFIG", WERR_NERR_BADUASCONFIG },
+       { "WERR_NERR_INVALIDUASOP", WERR_NERR_INVALIDUASOP },
+       { "WERR_NERR_LASTADMIN", WERR_NERR_LASTADMIN },
+       { "WERR_NERR_DCNOTFOUND", WERR_NERR_DCNOTFOUND },
+       { "WERR_NERR_LOGONTRACKINGERROR", WERR_NERR_LOGONTRACKINGERROR },
+       { "WERR_NERR_NETLOGONNOTSTARTED", WERR_NERR_NETLOGONNOTSTARTED },
+       { "WERR_NERR_CANNOTGROWUASFILE", WERR_NERR_CANNOTGROWUASFILE },
+       { "WERR_NERR_TIMEDIFFATDC", WERR_NERR_TIMEDIFFATDC },
+       { "WERR_NERR_PASSWORDMISMATCH", WERR_NERR_PASSWORDMISMATCH },
+       { "WERR_NERR_NOSUCHSERVER", WERR_NERR_NOSUCHSERVER },
+       { "WERR_NERR_NOSUCHSESSION", WERR_NERR_NOSUCHSESSION },
+       { "WERR_NERR_NOSUCHCONNECTION", WERR_NERR_NOSUCHCONNECTION },
+       { "WERR_NERR_TOOMANYSERVERS", WERR_NERR_TOOMANYSERVERS },
+       { "WERR_NERR_TOOMANYSESSIONS", WERR_NERR_TOOMANYSESSIONS },
+       { "WERR_NERR_TOOMANYCONNECTIONS", WERR_NERR_TOOMANYCONNECTIONS },
+       { "WERR_NERR_TOOMANYFILES", WERR_NERR_TOOMANYFILES },
+       { "WERR_NERR_NOALTERNATESERVERS", WERR_NERR_NOALTERNATESERVERS },
+       { "WERR_NERR_TRYDOWNLEVEL", WERR_NERR_TRYDOWNLEVEL },
+       { "WERR_NERR_UPSDRIVERNOTSTARTED", WERR_NERR_UPSDRIVERNOTSTARTED },
+       { "WERR_NERR_UPSINVALIDCONFIG", WERR_NERR_UPSINVALIDCONFIG },
+       { "WERR_NERR_UPSINVALIDCOMMPORT", WERR_NERR_UPSINVALIDCOMMPORT },
+       { "WERR_NERR_UPSSIGNALASSERTED", WERR_NERR_UPSSIGNALASSERTED },
+       { "WERR_NERR_UPSSHUTDOWNFAILED", WERR_NERR_UPSSHUTDOWNFAILED },
+       { "WERR_NERR_BADDOSRETCODE", WERR_NERR_BADDOSRETCODE },
+       { "WERR_NERR_PROGNEEDSEXTRAMEM", WERR_NERR_PROGNEEDSEXTRAMEM },
+       { "WERR_NERR_BADDOSFUNCTION", WERR_NERR_BADDOSFUNCTION },
+       { "WERR_NERR_REMOTEBOOTFAILED", WERR_NERR_REMOTEBOOTFAILED },
+       { "WERR_NERR_BADFILECHECKSUM", WERR_NERR_BADFILECHECKSUM },
+       { "WERR_NERR_NORPLBOOTSYSTEM", WERR_NERR_NORPLBOOTSYSTEM },
+       { "WERR_NERR_RPLLOADRNETBIOSERR", WERR_NERR_RPLLOADRNETBIOSERR },
+       { "WERR_NERR_RPLLOADRDISKERR", WERR_NERR_RPLLOADRDISKERR },
+       { "WERR_NERR_IMAGEPARAMERR", WERR_NERR_IMAGEPARAMERR },
+       { "WERR_NERR_TOOMANYIMAGEPARAMS", WERR_NERR_TOOMANYIMAGEPARAMS },
+       { "WERR_NERR_NONDOSFLOPPYUSED", WERR_NERR_NONDOSFLOPPYUSED },
+       { "WERR_NERR_RPLBOOTRESTART", WERR_NERR_RPLBOOTRESTART },
+       { "WERR_NERR_RPLSRVRCALLFAILED", WERR_NERR_RPLSRVRCALLFAILED },
+       { "WERR_NERR_CANTCONNECTRPLSRVR", WERR_NERR_CANTCONNECTRPLSRVR },
+       { "WERR_NERR_CANTOPENIMAGEFILE", WERR_NERR_CANTOPENIMAGEFILE },
+       { "WERR_NERR_CALLINGRPLSRVR", WERR_NERR_CALLINGRPLSRVR },
+       { "WERR_NERR_STARTINGRPLBOOT", WERR_NERR_STARTINGRPLBOOT },
+       { "WERR_NERR_RPLBOOTSERVICETERM", WERR_NERR_RPLBOOTSERVICETERM },
+       { "WERR_NERR_RPLBOOTSTARTFAILED", WERR_NERR_RPLBOOTSTARTFAILED },
+       { "WERR_NERR_RPL_CONNECTED", WERR_NERR_RPL_CONNECTED },
+       { "WERR_NERR_BROWSERCONFIGUREDTONOTRUN", WERR_NERR_BROWSERCONFIGUREDTONOTRUN },
+       { "WERR_NERR_RPLNOADAPTERSSTARTED", WERR_NERR_RPLNOADAPTERSSTARTED },
+       { "WERR_NERR_RPLBADREGISTRY", WERR_NERR_RPLBADREGISTRY },
+       { "WERR_NERR_RPLBADDATABASE", WERR_NERR_RPLBADDATABASE },
+       { "WERR_NERR_RPLRPLFILESSHARE", WERR_NERR_RPLRPLFILESSHARE },
+       { "WERR_NERR_RPLNOTRPLSERVER", WERR_NERR_RPLNOTRPLSERVER },
+       { "WERR_NERR_RPLCANNOTENUM", WERR_NERR_RPLCANNOTENUM },
+       { "WERR_NERR_RPLWKSTAINFOCORRUPTED", WERR_NERR_RPLWKSTAINFOCORRUPTED },
+       { "WERR_NERR_RPLWKSTANOTFOUND", WERR_NERR_RPLWKSTANOTFOUND },
+       { "WERR_NERR_RPLWKSTANAMEUNAVAILABLE", WERR_NERR_RPLWKSTANAMEUNAVAILABLE },
+       { "WERR_NERR_RPLPROFILEINFOCORRUPTED", WERR_NERR_RPLPROFILEINFOCORRUPTED },
+       { "WERR_NERR_RPLPROFILENOTFOUND", WERR_NERR_RPLPROFILENOTFOUND },
+       { "WERR_NERR_RPLPROFILENAMEUNAVAILABLE", WERR_NERR_RPLPROFILENAMEUNAVAILABLE },
+       { "WERR_NERR_RPLPROFILENOTEMPTY", WERR_NERR_RPLPROFILENOTEMPTY },
+       { "WERR_NERR_RPLCONFIGINFOCORRUPTED", WERR_NERR_RPLCONFIGINFOCORRUPTED },
+       { "WERR_NERR_RPLCONFIGNOTFOUND", WERR_NERR_RPLCONFIGNOTFOUND },
+       { "WERR_NERR_RPLADAPTERINFOCORRUPTED", WERR_NERR_RPLADAPTERINFOCORRUPTED },
+       { "WERR_NERR_RPLINTERNAL", WERR_NERR_RPLINTERNAL },
+       { "WERR_NERR_RPLVENDORINFOCORRUPTED", WERR_NERR_RPLVENDORINFOCORRUPTED },
+       { "WERR_NERR_RPLBOOTINFOCORRUPTED", WERR_NERR_RPLBOOTINFOCORRUPTED },
+       { "WERR_NERR_RPLWKSTANEEDSUSERACCT", WERR_NERR_RPLWKSTANEEDSUSERACCT },
+       { "WERR_NERR_RPLNEEDSRPLUSERACCT", WERR_NERR_RPLNEEDSRPLUSERACCT },
+       { "WERR_NERR_RPLBOOTNOTFOUND", WERR_NERR_RPLBOOTNOTFOUND },
+       { "WERR_NERR_RPLINCOMPATIBLEPROFILE", WERR_NERR_RPLINCOMPATIBLEPROFILE },
+       { "WERR_NERR_RPLADAPTERNAMEUNAVAILABLE", WERR_NERR_RPLADAPTERNAMEUNAVAILABLE },
+       { "WERR_NERR_RPLCONFIGNOTEMPTY", WERR_NERR_RPLCONFIGNOTEMPTY },
+       { "WERR_NERR_RPLBOOTINUSE", WERR_NERR_RPLBOOTINUSE },
+       { "WERR_NERR_RPLBACKUPDATABASE", WERR_NERR_RPLBACKUPDATABASE },
+       { "WERR_NERR_RPLADAPTERNOTFOUND", WERR_NERR_RPLADAPTERNOTFOUND },
+       { "WERR_NERR_RPLVENDORNOTFOUND", WERR_NERR_RPLVENDORNOTFOUND },
+       { "WERR_NERR_RPLVENDORNAMEUNAVAILABLE", WERR_NERR_RPLVENDORNAMEUNAVAILABLE },
+       { "WERR_NERR_RPLBOOTNAMEUNAVAILABLE", WERR_NERR_RPLBOOTNAMEUNAVAILABLE },
+       { "WERR_NERR_RPLCONFIGNAMEUNAVAILABLE", WERR_NERR_RPLCONFIGNAMEUNAVAILABLE },
+       { "WERR_NERR_DFSINTERNALCORRUPTION", WERR_NERR_DFSINTERNALCORRUPTION },
+       { "WERR_NERR_DFSVOLUMEDATACORRUPT", WERR_NERR_DFSVOLUMEDATACORRUPT },
+       { "WERR_NERR_DFSNOSUCHVOLUME", WERR_NERR_DFSNOSUCHVOLUME },
+       { "WERR_NERR_DFSVOLUMEALREADYEXISTS", WERR_NERR_DFSVOLUMEALREADYEXISTS },
+       { "WERR_NERR_DFSALREADYSHARED", WERR_NERR_DFSALREADYSHARED },
+       { "WERR_NERR_DFSNOSUCHSHARE", WERR_NERR_DFSNOSUCHSHARE },
+       { "WERR_NERR_DFSNOTALEAFVOLUME", WERR_NERR_DFSNOTALEAFVOLUME },
+       { "WERR_NERR_DFSLEAFVOLUME", WERR_NERR_DFSLEAFVOLUME },
+       { "WERR_NERR_DFSVOLUMEHASMULTIPLESERVERS", WERR_NERR_DFSVOLUMEHASMULTIPLESERVERS },
+       { "WERR_NERR_DFSCANTCREATEJUNCTIONPOINT", WERR_NERR_DFSCANTCREATEJUNCTIONPOINT },
+       { "WERR_NERR_DFSSERVERNOTDFSAWARE", WERR_NERR_DFSSERVERNOTDFSAWARE },
+       { "WERR_NERR_DFSBADRENAMEPATH", WERR_NERR_DFSBADRENAMEPATH },
+       { "WERR_NERR_DFSVOLUMEISOFFLINE", WERR_NERR_DFSVOLUMEISOFFLINE },
+       { "WERR_NERR_DFSNOSUCHSERVER", WERR_NERR_DFSNOSUCHSERVER },
+       { "WERR_NERR_DFSCYCLICALNAME", WERR_NERR_DFSCYCLICALNAME },
+       { "WERR_NERR_DFSNOTSUPPORTEDINSERVERDFS", WERR_NERR_DFSNOTSUPPORTEDINSERVERDFS },
+       { "WERR_NERR_DFSDUPLICATESERVICE", WERR_NERR_DFSDUPLICATESERVICE },
+       { "WERR_NERR_DFSCANTREMOVELASTSERVERSHARE", WERR_NERR_DFSCANTREMOVELASTSERVERSHARE },
+       { "WERR_NERR_DFSVOLUMEISINTERDFS", WERR_NERR_DFSVOLUMEISINTERDFS },
+       { "WERR_NERR_DFSINCONSISTENT", WERR_NERR_DFSINCONSISTENT },
+       { "WERR_NERR_DFSSERVERUPGRADED", WERR_NERR_DFSSERVERUPGRADED },
+       { "WERR_NERR_DFSDATAISIDENTICAL", WERR_NERR_DFSDATAISIDENTICAL },
+       { "WERR_NERR_DFSCANTREMOVEDFSROOT", WERR_NERR_DFSCANTREMOVEDFSROOT },
+       { "WERR_NERR_DFSCHILDORPARENTINDFS", WERR_NERR_DFSCHILDORPARENTINDFS },
+       { "WERR_NERR_DFSINTERNALERROR", WERR_NERR_DFSINTERNALERROR },
+       { "WERR_NERR_SETUPALREADYJOINED", WERR_NERR_SETUPALREADYJOINED },
+       { "WERR_NERR_SETUPNOTJOINED", WERR_NERR_SETUPNOTJOINED },
+       { "WERR_NERR_SETUPDOMAINCONTROLLER", WERR_NERR_SETUPDOMAINCONTROLLER },
+       { "WERR_NERR_DEFAULTJOINREQUIRED", WERR_NERR_DEFAULTJOINREQUIRED },
+       { "WERR_NERR_INVALIDWORKGROUPNAME", WERR_NERR_INVALIDWORKGROUPNAME },
+       { "WERR_NERR_NAMEUSESINCOMPATIBLECODEPAGE", WERR_NERR_NAMEUSESINCOMPATIBLECODEPAGE },
+       { "WERR_NERR_COMPUTERACCOUNTNOTFOUND", WERR_NERR_COMPUTERACCOUNTNOTFOUND },
+       { "WERR_NERR_PERSONALSKU", WERR_NERR_PERSONALSKU },
+       { "WERR_NERR_PASSWORDMUSTCHANGE", WERR_NERR_PASSWORDMUSTCHANGE },
+       { "WERR_NERR_ACCOUNTLOCKEDOUT", WERR_NERR_ACCOUNTLOCKEDOUT },
+       { "WERR_NERR_PASSWORDTOOLONG", WERR_NERR_PASSWORDTOOLONG },
+       { "WERR_NERR_PASSWORDNOTCOMPLEXENOUGH", WERR_NERR_PASSWORDNOTCOMPLEXENOUGH },
+       { "WERR_NERR_PASSWORDFILTERERROR", WERR_NERR_PASSWORDFILTERERROR },
+       { "WERR_SUCCESS_REBOOT_REQUIRED", WERR_SUCCESS_REBOOT_REQUIRED },
+       { "WERR_SUCCESS_RESTART_REQUIRED", WERR_SUCCESS_RESTART_REQUIRED },
+       { "WERR_PRINTER_NOT_FOUND", WERR_PRINTER_NOT_FOUND },
+       { "WERR_PRINTER_DRIVER_WARNED", WERR_PRINTER_DRIVER_WARNED },
+       { "WERR_PRINTER_DRIVER_BLOCKED", WERR_PRINTER_DRIVER_BLOCKED },
+       { "WERR_PRINTER_DRIVER_PACKAGE_IN_USE", WERR_PRINTER_DRIVER_PACKAGE_IN_USE },
+       { "WERR_CORE_DRIVER_PACKAGE_NOT_FOUND", WERR_CORE_DRIVER_PACKAGE_NOT_FOUND },
+       { "WERR_FAIL_REBOOT_REQUIRED", WERR_FAIL_REBOOT_REQUIRED },
+       { "WERR_FAIL_REBOOT_INITIATED", WERR_FAIL_REBOOT_INITIATED },
+       { "WERR_IO_REISSUE_AS_CACHED", WERR_IO_REISSUE_AS_CACHED },
+       { "WERR_WINS_INTERNAL", WERR_WINS_INTERNAL },
+       { "WERR_CAN_NOT_DEL_LOCAL_WINS", WERR_CAN_NOT_DEL_LOCAL_WINS },
+       { "WERR_STATIC_INIT", WERR_STATIC_INIT },
+       { "WERR_INC_BACKUP", WERR_INC_BACKUP },
+       { "WERR_FULL_BACKUP", WERR_FULL_BACKUP },
+       { "WERR_REC_NON_EXISTENT", WERR_REC_NON_EXISTENT },
+       { "WERR_RPL_NOT_ALLOWED", WERR_RPL_NOT_ALLOWED },
+       { "WERR_DHCP_ADDRESS_CONFLICT", WERR_DHCP_ADDRESS_CONFLICT },
+       { "WERR_WMI_GUID_NOT_FOUND", WERR_WMI_GUID_NOT_FOUND },
+       { "WERR_WMI_INSTANCE_NOT_FOUND", WERR_WMI_INSTANCE_NOT_FOUND },
+       { "WERR_WMI_ITEMID_NOT_FOUND", WERR_WMI_ITEMID_NOT_FOUND },
+       { "WERR_WMI_TRY_AGAIN", WERR_WMI_TRY_AGAIN },
+       { "WERR_WMI_DP_NOT_FOUND", WERR_WMI_DP_NOT_FOUND },
+       { "WERR_WMI_UNRESOLVED_INSTANCE_REF", WERR_WMI_UNRESOLVED_INSTANCE_REF },
+       { "WERR_WMI_ALREADY_ENABLED", WERR_WMI_ALREADY_ENABLED },
+       { "WERR_WMI_GUID_DISCONNECTED", WERR_WMI_GUID_DISCONNECTED },
+       { "WERR_WMI_SERVER_UNAVAILABLE", WERR_WMI_SERVER_UNAVAILABLE },
+       { "WERR_WMI_DP_FAILED", WERR_WMI_DP_FAILED },
+       { "WERR_WMI_INVALID_MOF", WERR_WMI_INVALID_MOF },
+       { "WERR_WMI_INVALID_REGINFO", WERR_WMI_INVALID_REGINFO },
+       { "WERR_WMI_ALREADY_DISABLED", WERR_WMI_ALREADY_DISABLED },
+       { "WERR_WMI_READ_ONLY", WERR_WMI_READ_ONLY },
+       { "WERR_WMI_SET_FAILURE", WERR_WMI_SET_FAILURE },
+       { "WERR_INVALID_MEDIA", WERR_INVALID_MEDIA },
+       { "WERR_INVALID_LIBRARY", WERR_INVALID_LIBRARY },
+       { "WERR_INVALID_MEDIA_POOL", WERR_INVALID_MEDIA_POOL },
+       { "WERR_DRIVE_MEDIA_MISMATCH", WERR_DRIVE_MEDIA_MISMATCH },
+       { "WERR_MEDIA_OFFLINE", WERR_MEDIA_OFFLINE },
+       { "WERR_LIBRARY_OFFLINE", WERR_LIBRARY_OFFLINE },
+       { "WERR_EMPTY", WERR_EMPTY },
+       { "WERR_NOT_EMPTY", WERR_NOT_EMPTY },
+       { "WERR_MEDIA_UNAVAILABLE", WERR_MEDIA_UNAVAILABLE },
+       { "WERR_RESOURCE_DISABLED", WERR_RESOURCE_DISABLED },
+       { "WERR_INVALID_CLEANER", WERR_INVALID_CLEANER },
+       { "WERR_UNABLE_TO_CLEAN", WERR_UNABLE_TO_CLEAN },
+       { "WERR_OBJECT_NOT_FOUND", WERR_OBJECT_NOT_FOUND },
+       { "WERR_DATABASE_FAILURE", WERR_DATABASE_FAILURE },
+       { "WERR_DATABASE_FULL", WERR_DATABASE_FULL },
+       { "WERR_MEDIA_INCOMPATIBLE", WERR_MEDIA_INCOMPATIBLE },
+       { "WERR_RESOURCE_NOT_PRESENT", WERR_RESOURCE_NOT_PRESENT },
+       { "WERR_INVALID_OPERATION", WERR_INVALID_OPERATION },
+       { "WERR_MEDIA_NOT_AVAILABLE", WERR_MEDIA_NOT_AVAILABLE },
+       { "WERR_REQUEST_REFUSED", WERR_REQUEST_REFUSED },
+       { "WERR_INVALID_DRIVE_OBJECT", WERR_INVALID_DRIVE_OBJECT },
+       { "WERR_LIBRARY_FULL", WERR_LIBRARY_FULL },
+       { "WERR_MEDIUM_NOT_ACCESSIBLE", WERR_MEDIUM_NOT_ACCESSIBLE },
+       { "WERR_UNABLE_TO_LOAD_MEDIUM", WERR_UNABLE_TO_LOAD_MEDIUM },
+       { "WERR_UNABLE_TO_INVENTORY_DRIVE", WERR_UNABLE_TO_INVENTORY_DRIVE },
+       { "WERR_UNABLE_TO_INVENTORY_SLOT", WERR_UNABLE_TO_INVENTORY_SLOT },
+       { "WERR_UNABLE_TO_INVENTORY_TRANSPORT", WERR_UNABLE_TO_INVENTORY_TRANSPORT },
+       { "WERR_TRANSPORT_FULL", WERR_TRANSPORT_FULL },
+       { "WERR_CONTROLLING_IEPORT", WERR_CONTROLLING_IEPORT },
+       { "WERR_UNABLE_TO_EJECT_MOUNTED_MEDIA", WERR_UNABLE_TO_EJECT_MOUNTED_MEDIA },
+       { "WERR_CLEANER_SLOT_SET", WERR_CLEANER_SLOT_SET },
+       { "WERR_CLEANER_SLOT_NOT_SET", WERR_CLEANER_SLOT_NOT_SET },
+       { "WERR_CLEANER_CARTRIDGE_SPENT", WERR_CLEANER_CARTRIDGE_SPENT },
+       { "WERR_UNEXPECTED_OMID", WERR_UNEXPECTED_OMID },
+       { "WERR_CANT_DELETE_LAST_ITEM", WERR_CANT_DELETE_LAST_ITEM },
+       { "WERR_MESSAGE_EXCEEDS_MAX_SIZE", WERR_MESSAGE_EXCEEDS_MAX_SIZE },
+       { "WERR_VOLUME_CONTAINS_SYS_FILES", WERR_VOLUME_CONTAINS_SYS_FILES },
+       { "WERR_INDIGENOUS_TYPE", WERR_INDIGENOUS_TYPE },
+       { "WERR_NO_SUPPORTING_DRIVES", WERR_NO_SUPPORTING_DRIVES },
+       { "WERR_CLEANER_CARTRIDGE_INSTALLED", WERR_CLEANER_CARTRIDGE_INSTALLED },
+       { "WERR_IEPORT_FULL", WERR_IEPORT_FULL },
+       { "WERR_FILE_OFFLINE", WERR_FILE_OFFLINE },
+       { "WERR_REMOTE_STORAGE_NOT_ACTIVE", WERR_REMOTE_STORAGE_NOT_ACTIVE },
+       { "WERR_REMOTE_STORAGE_MEDIA_ERROR", WERR_REMOTE_STORAGE_MEDIA_ERROR },
+       { "WERR_NOT_A_REPARSE_POINT", WERR_NOT_A_REPARSE_POINT },
+       { "WERR_REPARSE_ATTRIBUTE_CONFLICT", WERR_REPARSE_ATTRIBUTE_CONFLICT },
+       { "WERR_INVALID_REPARSE_DATA", WERR_INVALID_REPARSE_DATA },
+       { "WERR_REPARSE_TAG_INVALID", WERR_REPARSE_TAG_INVALID },
+       { "WERR_REPARSE_TAG_MISMATCH", WERR_REPARSE_TAG_MISMATCH },
+       { "WERR_VOLUME_NOT_SIS_ENABLED", WERR_VOLUME_NOT_SIS_ENABLED },
+       { "WERR_DEPENDENT_RESOURCE_EXISTS", WERR_DEPENDENT_RESOURCE_EXISTS },
+       { "WERR_DEPENDENCY_NOT_FOUND", WERR_DEPENDENCY_NOT_FOUND },
+       { "WERR_DEPENDENCY_ALREADY_EXISTS", WERR_DEPENDENCY_ALREADY_EXISTS },
+       { "WERR_RESOURCE_NOT_ONLINE", WERR_RESOURCE_NOT_ONLINE },
+       { "WERR_HOST_NODE_NOT_AVAILABLE", WERR_HOST_NODE_NOT_AVAILABLE },
+       { "WERR_RESOURCE_NOT_AVAILABLE", WERR_RESOURCE_NOT_AVAILABLE },
+       { "WERR_RESOURCE_NOT_FOUND", WERR_RESOURCE_NOT_FOUND },
+       { "WERR_SHUTDOWN_CLUSTER", WERR_SHUTDOWN_CLUSTER },
+       { "WERR_CANT_EVICT_ACTIVE_NODE", WERR_CANT_EVICT_ACTIVE_NODE },
+       { "WERR_OBJECT_ALREADY_EXISTS", WERR_OBJECT_ALREADY_EXISTS },
+       { "WERR_OBJECT_IN_LIST", WERR_OBJECT_IN_LIST },
+       { "WERR_GROUP_NOT_AVAILABLE", WERR_GROUP_NOT_AVAILABLE },
+       { "WERR_GROUP_NOT_FOUND", WERR_GROUP_NOT_FOUND },
+       { "WERR_GROUP_NOT_ONLINE", WERR_GROUP_NOT_ONLINE },
+       { "WERR_HOST_NODE_NOT_RESOURCE_OWNER", WERR_HOST_NODE_NOT_RESOURCE_OWNER },
+       { "WERR_HOST_NODE_NOT_GROUP_OWNER", WERR_HOST_NODE_NOT_GROUP_OWNER },
+       { "WERR_RESMON_CREATE_FAILED", WERR_RESMON_CREATE_FAILED },
+       { "WERR_RESMON_ONLINE_FAILED", WERR_RESMON_ONLINE_FAILED },
+       { "WERR_RESOURCE_ONLINE", WERR_RESOURCE_ONLINE },
+       { "WERR_QUORUM_RESOURCE", WERR_QUORUM_RESOURCE },
+       { "WERR_NOT_QUORUM_CAPABLE", WERR_NOT_QUORUM_CAPABLE },
+       { "WERR_CLUSTER_SHUTTING_DOWN", WERR_CLUSTER_SHUTTING_DOWN },
+       { "WERR_INVALID_STATE", WERR_INVALID_STATE },
+       { "WERR_RESOURCE_PROPERTIES_STORED", WERR_RESOURCE_PROPERTIES_STORED },
+       { "WERR_NOT_QUORUM_CLASS", WERR_NOT_QUORUM_CLASS },
+       { "WERR_CORE_RESOURCE", WERR_CORE_RESOURCE },
+       { "WERR_QUORUM_RESOURCE_ONLINE_FAILED", WERR_QUORUM_RESOURCE_ONLINE_FAILED },
+       { "WERR_QUORUMLOG_OPEN_FAILED", WERR_QUORUMLOG_OPEN_FAILED },
+       { "WERR_CLUSTERLOG_CORRUPT", WERR_CLUSTERLOG_CORRUPT },
+       { "WERR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE", WERR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE },
+       { "WERR_CLUSTERLOG_EXCEEDS_MAXSIZE", WERR_CLUSTERLOG_EXCEEDS_MAXSIZE },
+       { "WERR_CLUSTERLOG_CHKPOINT_NOT_FOUND", WERR_CLUSTERLOG_CHKPOINT_NOT_FOUND },
+       { "WERR_CLUSTERLOG_NOT_ENOUGH_SPACE", WERR_CLUSTERLOG_NOT_ENOUGH_SPACE },
+       { "WERR_QUORUM_OWNER_ALIVE", WERR_QUORUM_OWNER_ALIVE },
+       { "WERR_NETWORK_NOT_AVAILABLE", WERR_NETWORK_NOT_AVAILABLE },
+       { "WERR_NODE_NOT_AVAILABLE", WERR_NODE_NOT_AVAILABLE },
+       { "WERR_ALL_NODES_NOT_AVAILABLE", WERR_ALL_NODES_NOT_AVAILABLE },
+       { "WERR_RESOURCE_FAILED", WERR_RESOURCE_FAILED },
+       { "WERR_CLUSTER_INVALID_NODE", WERR_CLUSTER_INVALID_NODE },
+       { "WERR_CLUSTER_NODE_EXISTS", WERR_CLUSTER_NODE_EXISTS },
+       { "WERR_CLUSTER_JOIN_IN_PROGRESS", WERR_CLUSTER_JOIN_IN_PROGRESS },
+       { "WERR_CLUSTER_NODE_NOT_FOUND", WERR_CLUSTER_NODE_NOT_FOUND },
+       { "WERR_CLUSTER_LOCAL_NODE_NOT_FOUND", WERR_CLUSTER_LOCAL_NODE_NOT_FOUND },
+       { "WERR_CLUSTER_NETWORK_EXISTS", WERR_CLUSTER_NETWORK_EXISTS },
+       { "WERR_CLUSTER_NETWORK_NOT_FOUND", WERR_CLUSTER_NETWORK_NOT_FOUND },
+       { "WERR_CLUSTER_NETINTERFACE_EXISTS", WERR_CLUSTER_NETINTERFACE_EXISTS },
+       { "WERR_CLUSTER_NETINTERFACE_NOT_FOUND", WERR_CLUSTER_NETINTERFACE_NOT_FOUND },
+       { "WERR_CLUSTER_INVALID_REQUEST", WERR_CLUSTER_INVALID_REQUEST },
+       { "WERR_CLUSTER_INVALID_NETWORK_PROVIDER", WERR_CLUSTER_INVALID_NETWORK_PROVIDER },
+       { "WERR_CLUSTER_NODE_DOWN", WERR_CLUSTER_NODE_DOWN },
+       { "WERR_CLUSTER_NODE_UNREACHABLE", WERR_CLUSTER_NODE_UNREACHABLE },
+       { "WERR_CLUSTER_NODE_NOT_MEMBER", WERR_CLUSTER_NODE_NOT_MEMBER },
+       { "WERR_CLUSTER_JOIN_NOT_IN_PROGRESS", WERR_CLUSTER_JOIN_NOT_IN_PROGRESS },
+       { "WERR_CLUSTER_INVALID_NETWORK", WERR_CLUSTER_INVALID_NETWORK },
+       { "WERR_CLUSTER_NODE_UP", WERR_CLUSTER_NODE_UP },
+       { "WERR_CLUSTER_IPADDR_IN_USE", WERR_CLUSTER_IPADDR_IN_USE },
+       { "WERR_CLUSTER_NODE_NOT_PAUSED", WERR_CLUSTER_NODE_NOT_PAUSED },
+       { "WERR_CLUSTER_NO_SECURITY_CONTEXT", WERR_CLUSTER_NO_SECURITY_CONTEXT },
+       { "WERR_CLUSTER_NETWORK_NOT_INTERNAL", WERR_CLUSTER_NETWORK_NOT_INTERNAL },
+       { "WERR_CLUSTER_NODE_ALREADY_UP", WERR_CLUSTER_NODE_ALREADY_UP },
+       { "WERR_CLUSTER_NODE_ALREADY_DOWN", WERR_CLUSTER_NODE_ALREADY_DOWN },
+       { "WERR_CLUSTER_NETWORK_ALREADY_ONLINE", WERR_CLUSTER_NETWORK_ALREADY_ONLINE },
+       { "WERR_CLUSTER_NETWORK_ALREADY_OFFLINE", WERR_CLUSTER_NETWORK_ALREADY_OFFLINE },
+       { "WERR_CLUSTER_NODE_ALREADY_MEMBER", WERR_CLUSTER_NODE_ALREADY_MEMBER },
+       { "WERR_CLUSTER_LAST_INTERNAL_NETWORK", WERR_CLUSTER_LAST_INTERNAL_NETWORK },
+       { "WERR_CLUSTER_NETWORK_HAS_DEPENDENTS", WERR_CLUSTER_NETWORK_HAS_DEPENDENTS },
+       { "WERR_INVALID_OPERATION_ON_QUORUM", WERR_INVALID_OPERATION_ON_QUORUM },
+       { "WERR_DEPENDENCY_NOT_ALLOWED", WERR_DEPENDENCY_NOT_ALLOWED },
+       { "WERR_CLUSTER_NODE_PAUSED", WERR_CLUSTER_NODE_PAUSED },
+       { "WERR_NODE_CANT_HOST_RESOURCE", WERR_NODE_CANT_HOST_RESOURCE },
+       { "WERR_CLUSTER_NODE_NOT_READY", WERR_CLUSTER_NODE_NOT_READY },
+       { "WERR_CLUSTER_NODE_SHUTTING_DOWN", WERR_CLUSTER_NODE_SHUTTING_DOWN },
+       { "WERR_CLUSTER_JOIN_ABORTED", WERR_CLUSTER_JOIN_ABORTED },
+       { "WERR_CLUSTER_INCOMPATIBLE_VERSIONS", WERR_CLUSTER_INCOMPATIBLE_VERSIONS },
+       { "WERR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED", WERR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED },
+       { "WERR_CLUSTER_SYSTEM_CONFIG_CHANGED", WERR_CLUSTER_SYSTEM_CONFIG_CHANGED },
+       { "WERR_CLUSTER_RESOURCE_TYPE_NOT_FOUND", WERR_CLUSTER_RESOURCE_TYPE_NOT_FOUND },
+       { "WERR_CLUSTER_RESTYPE_NOT_SUPPORTED", WERR_CLUSTER_RESTYPE_NOT_SUPPORTED },
+       { "WERR_CLUSTER_RESNAME_NOT_FOUND", WERR_CLUSTER_RESNAME_NOT_FOUND },
+       { "WERR_CLUSTER_NO_RPC_PACKAGES_REGISTERED", WERR_CLUSTER_NO_RPC_PACKAGES_REGISTERED },
+       { "WERR_CLUSTER_OWNER_NOT_IN_PREFLIST", WERR_CLUSTER_OWNER_NOT_IN_PREFLIST },
+       { "WERR_CLUSTER_DATABASE_SEQMISMATCH", WERR_CLUSTER_DATABASE_SEQMISMATCH },
+       { "WERR_RESMON_INVALID_STATE", WERR_RESMON_INVALID_STATE },
+       { "WERR_CLUSTER_GUM_NOT_LOCKER", WERR_CLUSTER_GUM_NOT_LOCKER },
+       { "WERR_QUORUM_DISK_NOT_FOUND", WERR_QUORUM_DISK_NOT_FOUND },
+       { "WERR_DATABASE_BACKUP_CORRUPT", WERR_DATABASE_BACKUP_CORRUPT },
+       { "WERR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT", WERR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT },
+       { "WERR_RESOURCE_PROPERTY_UNCHANGEABLE", WERR_RESOURCE_PROPERTY_UNCHANGEABLE },
+       { "WERR_CLUSTER_MEMBERSHIP_INVALID_STATE", WERR_CLUSTER_MEMBERSHIP_INVALID_STATE },
+       { "WERR_CLUSTER_QUORUMLOG_NOT_FOUND", WERR_CLUSTER_QUORUMLOG_NOT_FOUND },
+       { "WERR_CLUSTER_MEMBERSHIP_HALT", WERR_CLUSTER_MEMBERSHIP_HALT },
+       { "WERR_CLUSTER_INSTANCE_ID_MISMATCH", WERR_CLUSTER_INSTANCE_ID_MISMATCH },
+       { "WERR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP", WERR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP },
+       { "WERR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH", WERR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH },
+       { "WERR_CLUSTER_EVICT_WITHOUT_CLEANUP", WERR_CLUSTER_EVICT_WITHOUT_CLEANUP },
+       { "WERR_CLUSTER_PARAMETER_MISMATCH", WERR_CLUSTER_PARAMETER_MISMATCH },
+       { "WERR_NODE_CANNOT_BE_CLUSTERED", WERR_NODE_CANNOT_BE_CLUSTERED },
+       { "WERR_CLUSTER_WRONG_OS_VERSION", WERR_CLUSTER_WRONG_OS_VERSION },
+       { "WERR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME", WERR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME },
+       { "WERR_CLUSCFG_ALREADY_COMMITTED", WERR_CLUSCFG_ALREADY_COMMITTED },
+       { "WERR_CLUSCFG_ROLLBACK_FAILED", WERR_CLUSCFG_ROLLBACK_FAILED },
+       { "WERR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT", WERR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT },
+       { "WERR_CLUSTER_OLD_VERSION", WERR_CLUSTER_OLD_VERSION },
+       { "WERR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME", WERR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME },
+       { "WERR_CLUSTER_NO_NET_ADAPTERS", WERR_CLUSTER_NO_NET_ADAPTERS },
+       { "WERR_CLUSTER_POISONED", WERR_CLUSTER_POISONED },
+       { "WERR_CLUSTER_GROUP_MOVING", WERR_CLUSTER_GROUP_MOVING },
+       { "WERR_CLUSTER_RESOURCE_TYPE_BUSY", WERR_CLUSTER_RESOURCE_TYPE_BUSY },
+       { "WERR_RESOURCE_CALL_TIMED_OUT", WERR_RESOURCE_CALL_TIMED_OUT },
+       { "WERR_INVALID_CLUSTER_IPV6_ADDRESS", WERR_INVALID_CLUSTER_IPV6_ADDRESS },
+       { "WERR_CLUSTER_INTERNAL_INVALID_FUNCTION", WERR_CLUSTER_INTERNAL_INVALID_FUNCTION },
+       { "WERR_CLUSTER_PARAMETER_OUT_OF_BOUNDS", WERR_CLUSTER_PARAMETER_OUT_OF_BOUNDS },
+       { "WERR_CLUSTER_PARTIAL_SEND", WERR_CLUSTER_PARTIAL_SEND },
+       { "WERR_CLUSTER_REGISTRY_INVALID_FUNCTION", WERR_CLUSTER_REGISTRY_INVALID_FUNCTION },
+       { "WERR_CLUSTER_INVALID_STRING_TERMINATION", WERR_CLUSTER_INVALID_STRING_TERMINATION },
+       { "WERR_CLUSTER_INVALID_STRING_FORMAT", WERR_CLUSTER_INVALID_STRING_FORMAT },
+       { "WERR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS", WERR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS },
+       { "WERR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS", WERR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS },
+       { "WERR_CLUSTER_NULL_DATA", WERR_CLUSTER_NULL_DATA },
+       { "WERR_CLUSTER_PARTIAL_READ", WERR_CLUSTER_PARTIAL_READ },
+       { "WERR_CLUSTER_PARTIAL_WRITE", WERR_CLUSTER_PARTIAL_WRITE },
+       { "WERR_CLUSTER_CANT_DESERIALIZE_DATA", WERR_CLUSTER_CANT_DESERIALIZE_DATA },
+       { "WERR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT", WERR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT },
+       { "WERR_CLUSTER_NO_QUORUM", WERR_CLUSTER_NO_QUORUM },
+       { "WERR_CLUSTER_INVALID_IPV6_NETWORK", WERR_CLUSTER_INVALID_IPV6_NETWORK },
+       { "WERR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK", WERR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK },
+       { "WERR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP", WERR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP },
+       { "WERR_ENCRYPTION_FAILED", WERR_ENCRYPTION_FAILED },
+       { "WERR_DECRYPTION_FAILED", WERR_DECRYPTION_FAILED },
+       { "WERR_FILE_ENCRYPTED", WERR_FILE_ENCRYPTED },
+       { "WERR_NO_RECOVERY_POLICY", WERR_NO_RECOVERY_POLICY },
+       { "WERR_NO_EFS", WERR_NO_EFS },
+       { "WERR_WRONG_EFS", WERR_WRONG_EFS },
+       { "WERR_NO_USER_KEYS", WERR_NO_USER_KEYS },
+       { "WERR_FILE_NOT_ENCRYPTED", WERR_FILE_NOT_ENCRYPTED },
+       { "WERR_NOT_EXPORT_FORMAT", WERR_NOT_EXPORT_FORMAT },
+       { "WERR_FILE_READ_ONLY", WERR_FILE_READ_ONLY },
+       { "WERR_DIR_EFS_DISALLOWED", WERR_DIR_EFS_DISALLOWED },
+       { "WERR_EFS_SERVER_NOT_TRUSTED", WERR_EFS_SERVER_NOT_TRUSTED },
+       { "WERR_BAD_RECOVERY_POLICY", WERR_BAD_RECOVERY_POLICY },
+       { "WERR_EFS_ALG_BLOB_TOO_BIG", WERR_EFS_ALG_BLOB_TOO_BIG },
+       { "WERR_VOLUME_NOT_SUPPORT_EFS", WERR_VOLUME_NOT_SUPPORT_EFS },
+       { "WERR_EFS_DISABLED", WERR_EFS_DISABLED },
+       { "WERR_EFS_VERSION_NOT_SUPPORT", WERR_EFS_VERSION_NOT_SUPPORT },
+       { "WERR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE", WERR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE },
+       { "WERR_CS_ENCRYPTION_UNSUPPORTED_SERVER", WERR_CS_ENCRYPTION_UNSUPPORTED_SERVER },
+       { "WERR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE", WERR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE },
+       { "WERR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE", WERR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE },
+       { "WERR_CS_ENCRYPTION_FILE_NOT_CSE", WERR_CS_ENCRYPTION_FILE_NOT_CSE },
+       { "WERR_NO_BROWSER_SERVERS_FOUND", WERR_NO_BROWSER_SERVERS_FOUND },
+       { "WERR_LOG_SECTOR_INVALID", WERR_LOG_SECTOR_INVALID },
+       { "WERR_LOG_SECTOR_PARITY_INVALID", WERR_LOG_SECTOR_PARITY_INVALID },
+       { "WERR_LOG_SECTOR_REMAPPED", WERR_LOG_SECTOR_REMAPPED },
+       { "WERR_LOG_BLOCK_INCOMPLETE", WERR_LOG_BLOCK_INCOMPLETE },
+       { "WERR_LOG_INVALID_RANGE", WERR_LOG_INVALID_RANGE },
+       { "WERR_LOG_BLOCKS_EXHAUSTED", WERR_LOG_BLOCKS_EXHAUSTED },
+       { "WERR_LOG_READ_CONTEXT_INVALID", WERR_LOG_READ_CONTEXT_INVALID },
+       { "WERR_LOG_RESTART_INVALID", WERR_LOG_RESTART_INVALID },
+       { "WERR_LOG_BLOCK_VERSION", WERR_LOG_BLOCK_VERSION },
+       { "WERR_LOG_BLOCK_INVALID", WERR_LOG_BLOCK_INVALID },
+       { "WERR_LOG_READ_MODE_INVALID", WERR_LOG_READ_MODE_INVALID },
+       { "WERR_LOG_NO_RESTART", WERR_LOG_NO_RESTART },
+       { "WERR_LOG_METADATA_CORRUPT", WERR_LOG_METADATA_CORRUPT },
+       { "WERR_LOG_METADATA_INVALID", WERR_LOG_METADATA_INVALID },
+       { "WERR_LOG_METADATA_INCONSISTENT", WERR_LOG_METADATA_INCONSISTENT },
+       { "WERR_LOG_RESERVATION_INVALID", WERR_LOG_RESERVATION_INVALID },
+       { "WERR_LOG_CANT_DELETE", WERR_LOG_CANT_DELETE },
+       { "WERR_LOG_CONTAINER_LIMIT_EXCEEDED", WERR_LOG_CONTAINER_LIMIT_EXCEEDED },
+       { "WERR_LOG_START_OF_LOG", WERR_LOG_START_OF_LOG },
+       { "WERR_LOG_POLICY_ALREADY_INSTALLED", WERR_LOG_POLICY_ALREADY_INSTALLED },
+       { "WERR_LOG_POLICY_NOT_INSTALLED", WERR_LOG_POLICY_NOT_INSTALLED },
+       { "WERR_LOG_POLICY_INVALID", WERR_LOG_POLICY_INVALID },
+       { "WERR_LOG_POLICY_CONFLICT", WERR_LOG_POLICY_CONFLICT },
+       { "WERR_LOG_PINNED_ARCHIVE_TAIL", WERR_LOG_PINNED_ARCHIVE_TAIL },
+       { "WERR_LOG_RECORD_NONEXISTENT", WERR_LOG_RECORD_NONEXISTENT },
+       { "WERR_LOG_RECORDS_RESERVED_INVALID", WERR_LOG_RECORDS_RESERVED_INVALID },
+       { "WERR_LOG_SPACE_RESERVED_INVALID", WERR_LOG_SPACE_RESERVED_INVALID },
+       { "WERR_LOG_TAIL_INVALID", WERR_LOG_TAIL_INVALID },
+       { "WERR_LOG_FULL", WERR_LOG_FULL },
+       { "WERR_COULD_NOT_RESIZE_LOG", WERR_COULD_NOT_RESIZE_LOG },
+       { "WERR_LOG_MULTIPLEXED", WERR_LOG_MULTIPLEXED },
+       { "WERR_LOG_DEDICATED", WERR_LOG_DEDICATED },
+       { "WERR_LOG_ARCHIVE_NOT_IN_PROGRESS", WERR_LOG_ARCHIVE_NOT_IN_PROGRESS },
+       { "WERR_LOG_ARCHIVE_IN_PROGRESS", WERR_LOG_ARCHIVE_IN_PROGRESS },
+       { "WERR_LOG_EPHEMERAL", WERR_LOG_EPHEMERAL },
+       { "WERR_LOG_NOT_ENOUGH_CONTAINERS", WERR_LOG_NOT_ENOUGH_CONTAINERS },
+       { "WERR_LOG_CLIENT_ALREADY_REGISTERED", WERR_LOG_CLIENT_ALREADY_REGISTERED },
+       { "WERR_LOG_CLIENT_NOT_REGISTERED", WERR_LOG_CLIENT_NOT_REGISTERED },
+       { "WERR_LOG_FULL_HANDLER_IN_PROGRESS", WERR_LOG_FULL_HANDLER_IN_PROGRESS },
+       { "WERR_LOG_CONTAINER_READ_FAILED", WERR_LOG_CONTAINER_READ_FAILED },
+       { "WERR_LOG_CONTAINER_WRITE_FAILED", WERR_LOG_CONTAINER_WRITE_FAILED },
+       { "WERR_LOG_CONTAINER_OPEN_FAILED", WERR_LOG_CONTAINER_OPEN_FAILED },
+       { "WERR_LOG_CONTAINER_STATE_INVALID", WERR_LOG_CONTAINER_STATE_INVALID },
+       { "WERR_LOG_STATE_INVALID", WERR_LOG_STATE_INVALID },
+       { "WERR_LOG_PINNED", WERR_LOG_PINNED },
+       { "WERR_LOG_METADATA_FLUSH_FAILED", WERR_LOG_METADATA_FLUSH_FAILED },
+       { "WERR_LOG_INCONSISTENT_SECURITY", WERR_LOG_INCONSISTENT_SECURITY },
+       { "WERR_LOG_APPENDED_FLUSH_FAILED", WERR_LOG_APPENDED_FLUSH_FAILED },
+       { "WERR_LOG_PINNED_RESERVATION", WERR_LOG_PINNED_RESERVATION },
+       { "WERR_INVALID_TRANSACTION", WERR_INVALID_TRANSACTION },
+       { "WERR_TRANSACTION_NOT_ACTIVE", WERR_TRANSACTION_NOT_ACTIVE },
+       { "WERR_TRANSACTION_REQUEST_NOT_VALID", WERR_TRANSACTION_REQUEST_NOT_VALID },
+       { "WERR_TRANSACTION_NOT_REQUESTED", WERR_TRANSACTION_NOT_REQUESTED },
+       { "WERR_TRANSACTION_ALREADY_ABORTED", WERR_TRANSACTION_ALREADY_ABORTED },
+       { "WERR_TRANSACTION_ALREADY_COMMITTED", WERR_TRANSACTION_ALREADY_COMMITTED },
+       { "WERR_TM_INITIALIZATION_FAILED", WERR_TM_INITIALIZATION_FAILED },
+       { "WERR_RESOURCEMANAGER_READ_ONLY", WERR_RESOURCEMANAGER_READ_ONLY },
+       { "WERR_TRANSACTION_NOT_JOINED", WERR_TRANSACTION_NOT_JOINED },
+       { "WERR_TRANSACTION_SUPERIOR_EXISTS", WERR_TRANSACTION_SUPERIOR_EXISTS },
+       { "WERR_CRM_PROTOCOL_ALREADY_EXISTS", WERR_CRM_PROTOCOL_ALREADY_EXISTS },
+       { "WERR_TRANSACTION_PROPAGATION_FAILED", WERR_TRANSACTION_PROPAGATION_FAILED },
+       { "WERR_CRM_PROTOCOL_NOT_FOUND", WERR_CRM_PROTOCOL_NOT_FOUND },
+       { "WERR_TRANSACTION_INVALID_MARSHALL_BUFFER", WERR_TRANSACTION_INVALID_MARSHALL_BUFFER },
+       { "WERR_CURRENT_TRANSACTION_NOT_VALID", WERR_CURRENT_TRANSACTION_NOT_VALID },
+       { "WERR_TRANSACTION_NOT_FOUND", WERR_TRANSACTION_NOT_FOUND },
+       { "WERR_RESOURCEMANAGER_NOT_FOUND", WERR_RESOURCEMANAGER_NOT_FOUND },
+       { "WERR_ENLISTMENT_NOT_FOUND", WERR_ENLISTMENT_NOT_FOUND },
+       { "WERR_TRANSACTIONMANAGER_NOT_FOUND", WERR_TRANSACTIONMANAGER_NOT_FOUND },
+       { "WERR_TRANSACTIONMANAGER_NOT_ONLINE", WERR_TRANSACTIONMANAGER_NOT_ONLINE },
+       { "WERR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION", WERR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION },
+       { "WERR_TRANSACTIONAL_CONFLICT", WERR_TRANSACTIONAL_CONFLICT },
+       { "WERR_RM_NOT_ACTIVE", WERR_RM_NOT_ACTIVE },
+       { "WERR_RM_METADATA_CORRUPT", WERR_RM_METADATA_CORRUPT },
+       { "WERR_DIRECTORY_NOT_RM", WERR_DIRECTORY_NOT_RM },
+       { "WERR_TRANSACTIONS_UNSUPPORTED_REMOTE", WERR_TRANSACTIONS_UNSUPPORTED_REMOTE },
+       { "WERR_LOG_RESIZE_INVALID_SIZE", WERR_LOG_RESIZE_INVALID_SIZE },
+       { "WERR_OBJECT_NO_LONGER_EXISTS", WERR_OBJECT_NO_LONGER_EXISTS },
+       { "WERR_STREAM_MINIVERSION_NOT_FOUND", WERR_STREAM_MINIVERSION_NOT_FOUND },
+       { "WERR_STREAM_MINIVERSION_NOT_VALID", WERR_STREAM_MINIVERSION_NOT_VALID },
+       { "WERR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION", WERR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION },
+       { "WERR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT", WERR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT },
+       { "WERR_CANT_CREATE_MORE_STREAM_MINIVERSIONS", WERR_CANT_CREATE_MORE_STREAM_MINIVERSIONS },
+       { "WERR_REMOTE_FILE_VERSION_MISMATCH", WERR_REMOTE_FILE_VERSION_MISMATCH },
+       { "WERR_HANDLE_NO_LONGER_VALID", WERR_HANDLE_NO_LONGER_VALID },
+       { "WERR_NO_TXF_METADATA", WERR_NO_TXF_METADATA },
+       { "WERR_LOG_CORRUPTION_DETECTED", WERR_LOG_CORRUPTION_DETECTED },
+       { "WERR_CANT_RECOVER_WITH_HANDLE_OPEN", WERR_CANT_RECOVER_WITH_HANDLE_OPEN },
+       { "WERR_RM_DISCONNECTED", WERR_RM_DISCONNECTED },
+       { "WERR_ENLISTMENT_NOT_SUPERIOR", WERR_ENLISTMENT_NOT_SUPERIOR },
+       { "WERR_RECOVERY_NOT_NEEDED", WERR_RECOVERY_NOT_NEEDED },
+       { "WERR_RM_ALREADY_STARTED", WERR_RM_ALREADY_STARTED },
+       { "WERR_FILE_IDENTITY_NOT_PERSISTENT", WERR_FILE_IDENTITY_NOT_PERSISTENT },
+       { "WERR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY", WERR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY },
+       { "WERR_CANT_CROSS_RM_BOUNDARY", WERR_CANT_CROSS_RM_BOUNDARY },
+       { "WERR_TXF_DIR_NOT_EMPTY", WERR_TXF_DIR_NOT_EMPTY },
+       { "WERR_INDOUBT_TRANSACTIONS_EXIST", WERR_INDOUBT_TRANSACTIONS_EXIST },
+       { "WERR_TM_VOLATILE", WERR_TM_VOLATILE },
+       { "WERR_ROLLBACK_TIMER_EXPIRED", WERR_ROLLBACK_TIMER_EXPIRED },
+       { "WERR_TXF_ATTRIBUTE_CORRUPT", WERR_TXF_ATTRIBUTE_CORRUPT },
+       { "WERR_EFS_NOT_ALLOWED_IN_TRANSACTION", WERR_EFS_NOT_ALLOWED_IN_TRANSACTION },
+       { "WERR_TRANSACTIONAL_OPEN_NOT_ALLOWED", WERR_TRANSACTIONAL_OPEN_NOT_ALLOWED },
+       { "WERR_LOG_GROWTH_FAILED", WERR_LOG_GROWTH_FAILED },
+       { "WERR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE", WERR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE },
+       { "WERR_TXF_METADATA_ALREADY_PRESENT", WERR_TXF_METADATA_ALREADY_PRESENT },
+       { "WERR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET", WERR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET },
+       { "WERR_TRANSACTION_REQUIRED_PROMOTION", WERR_TRANSACTION_REQUIRED_PROMOTION },
+       { "WERR_CANNOT_EXECUTE_FILE_IN_TRANSACTION", WERR_CANNOT_EXECUTE_FILE_IN_TRANSACTION },
+       { "WERR_TRANSACTIONS_NOT_FROZEN", WERR_TRANSACTIONS_NOT_FROZEN },
+       { "WERR_TRANSACTION_FREEZE_IN_PROGRESS", WERR_TRANSACTION_FREEZE_IN_PROGRESS },
+       { "WERR_NOT_SNAPSHOT_VOLUME", WERR_NOT_SNAPSHOT_VOLUME },
+       { "WERR_NO_SAVEPOINT_WITH_OPEN_FILES", WERR_NO_SAVEPOINT_WITH_OPEN_FILES },
+       { "WERR_DATA_LOST_REPAIR", WERR_DATA_LOST_REPAIR },
+       { "WERR_SPARSE_NOT_ALLOWED_IN_TRANSACTION", WERR_SPARSE_NOT_ALLOWED_IN_TRANSACTION },
+       { "WERR_TM_IDENTITY_MISMATCH", WERR_TM_IDENTITY_MISMATCH },
+       { "WERR_FLOATED_SECTION", WERR_FLOATED_SECTION },
+       { "WERR_CANNOT_ACCEPT_TRANSACTED_WORK", WERR_CANNOT_ACCEPT_TRANSACTED_WORK },
+       { "WERR_CANNOT_ABORT_TRANSACTIONS", WERR_CANNOT_ABORT_TRANSACTIONS },
+       { "WERR_CTX_WINSTATION_NAME_INVALID", WERR_CTX_WINSTATION_NAME_INVALID },
+       { "WERR_CTX_INVALID_PD", WERR_CTX_INVALID_PD },
+       { "WERR_CTX_PD_NOT_FOUND", WERR_CTX_PD_NOT_FOUND },
+       { "WERR_CTX_WD_NOT_FOUND", WERR_CTX_WD_NOT_FOUND },
+       { "WERR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY", WERR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY },
+       { "WERR_CTX_SERVICE_NAME_COLLISION", WERR_CTX_SERVICE_NAME_COLLISION },
+       { "WERR_CTX_CLOSE_PENDING", WERR_CTX_CLOSE_PENDING },
+       { "WERR_CTX_NO_OUTBUF", WERR_CTX_NO_OUTBUF },
+       { "WERR_CTX_MODEM_INF_NOT_FOUND", WERR_CTX_MODEM_INF_NOT_FOUND },
+       { "WERR_CTX_INVALID_MODEMNAME", WERR_CTX_INVALID_MODEMNAME },
+       { "WERR_CTX_MODEM_RESPONSE_ERROR", WERR_CTX_MODEM_RESPONSE_ERROR },
+       { "WERR_CTX_MODEM_RESPONSE_TIMEOUT", WERR_CTX_MODEM_RESPONSE_TIMEOUT },
+       { "WERR_CTX_MODEM_RESPONSE_NO_CARRIER", WERR_CTX_MODEM_RESPONSE_NO_CARRIER },
+       { "WERR_CTX_MODEM_RESPONSE_NO_DIALTONE", WERR_CTX_MODEM_RESPONSE_NO_DIALTONE },
+       { "WERR_CTX_MODEM_RESPONSE_BUSY", WERR_CTX_MODEM_RESPONSE_BUSY },
+       { "WERR_CTX_MODEM_RESPONSE_VOICE", WERR_CTX_MODEM_RESPONSE_VOICE },
+       { "WERR_CTX_TD_ERROR", WERR_CTX_TD_ERROR },
+       { "WERR_CTX_WINSTATION_NOT_FOUND", WERR_CTX_WINSTATION_NOT_FOUND },
+       { "WERR_CTX_WINSTATION_ALREADY_EXISTS", WERR_CTX_WINSTATION_ALREADY_EXISTS },
+       { "WERR_CTX_WINSTATION_BUSY", WERR_CTX_WINSTATION_BUSY },
+       { "WERR_CTX_BAD_VIDEO_MODE", WERR_CTX_BAD_VIDEO_MODE },
+       { "WERR_CTX_GRAPHICS_INVALID", WERR_CTX_GRAPHICS_INVALID },
+       { "WERR_CTX_LOGON_DISABLED", WERR_CTX_LOGON_DISABLED },
+       { "WERR_CTX_NOT_CONSOLE", WERR_CTX_NOT_CONSOLE },
+       { "WERR_CTX_CLIENT_QUERY_TIMEOUT", WERR_CTX_CLIENT_QUERY_TIMEOUT },
+       { "WERR_CTX_CONSOLE_DISCONNECT", WERR_CTX_CONSOLE_DISCONNECT },
+       { "WERR_CTX_CONSOLE_CONNECT", WERR_CTX_CONSOLE_CONNECT },
+       { "WERR_CTX_SHADOW_DENIED", WERR_CTX_SHADOW_DENIED },
+       { "WERR_CTX_WINSTATION_ACCESS_DENIED", WERR_CTX_WINSTATION_ACCESS_DENIED },
+       { "WERR_CTX_INVALID_WD", WERR_CTX_INVALID_WD },
+       { "WERR_CTX_SHADOW_INVALID", WERR_CTX_SHADOW_INVALID },
+       { "WERR_CTX_SHADOW_DISABLED", WERR_CTX_SHADOW_DISABLED },
+       { "WERR_CTX_CLIENT_LICENSE_IN_USE", WERR_CTX_CLIENT_LICENSE_IN_USE },
+       { "WERR_CTX_CLIENT_LICENSE_NOT_SET", WERR_CTX_CLIENT_LICENSE_NOT_SET },
+       { "WERR_CTX_LICENSE_NOT_AVAILABLE", WERR_CTX_LICENSE_NOT_AVAILABLE },
+       { "WERR_CTX_LICENSE_CLIENT_INVALID", WERR_CTX_LICENSE_CLIENT_INVALID },
+       { "WERR_CTX_LICENSE_EXPIRED", WERR_CTX_LICENSE_EXPIRED },
+       { "WERR_CTX_SHADOW_NOT_RUNNING", WERR_CTX_SHADOW_NOT_RUNNING },
+       { "WERR_CTX_SHADOW_ENDED_BY_MODE_CHANGE", WERR_CTX_SHADOW_ENDED_BY_MODE_CHANGE },
+       { "WERR_ACTIVATION_COUNT_EXCEEDED", WERR_ACTIVATION_COUNT_EXCEEDED },
+       { "WERR_CTX_WINSTATIONS_DISABLED", WERR_CTX_WINSTATIONS_DISABLED },
+       { "WERR_CTX_ENCRYPTION_LEVEL_REQUIRED", WERR_CTX_ENCRYPTION_LEVEL_REQUIRED },
+       { "WERR_CTX_SESSION_IN_USE", WERR_CTX_SESSION_IN_USE },
+       { "WERR_CTX_NO_FORCE_LOGOFF", WERR_CTX_NO_FORCE_LOGOFF },
+       { "WERR_CTX_ACCOUNT_RESTRICTION", WERR_CTX_ACCOUNT_RESTRICTION },
+       { "WERR_RDP_PROTOCOL_ERROR", WERR_RDP_PROTOCOL_ERROR },
+       { "WERR_CTX_CDM_CONNECT", WERR_CTX_CDM_CONNECT },
+       { "WERR_CTX_CDM_DISCONNECT", WERR_CTX_CDM_DISCONNECT },
+       { "WERR_CTX_SECURITY_LAYER_ERROR", WERR_CTX_SECURITY_LAYER_ERROR },
+       { "WERR_TS_INCOMPATIBLE_SESSIONS", WERR_TS_INCOMPATIBLE_SESSIONS },
+       { "WERR_FRS_ERR_INVALID_API_SEQUENCE", WERR_FRS_ERR_INVALID_API_SEQUENCE },
+       { "WERR_FRS_ERR_STARTING_SERVICE", WERR_FRS_ERR_STARTING_SERVICE },
+       { "WERR_FRS_ERR_STOPPING_SERVICE", WERR_FRS_ERR_STOPPING_SERVICE },
+       { "WERR_FRS_ERR_INTERNAL_API", WERR_FRS_ERR_INTERNAL_API },
+       { "WERR_FRS_ERR_INTERNAL", WERR_FRS_ERR_INTERNAL },
+       { "WERR_FRS_ERR_SERVICE_COMM", WERR_FRS_ERR_SERVICE_COMM },
+       { "WERR_FRS_ERR_INSUFFICIENT_PRIV", WERR_FRS_ERR_INSUFFICIENT_PRIV },
+       { "WERR_FRS_ERR_AUTHENTICATION", WERR_FRS_ERR_AUTHENTICATION },
+       { "WERR_FRS_ERR_PARENT_INSUFFICIENT_PRIV", WERR_FRS_ERR_PARENT_INSUFFICIENT_PRIV },
+       { "WERR_FRS_ERR_PARENT_AUTHENTICATION", WERR_FRS_ERR_PARENT_AUTHENTICATION },
+       { "WERR_FRS_ERR_CHILD_TO_PARENT_COMM", WERR_FRS_ERR_CHILD_TO_PARENT_COMM },
+       { "WERR_FRS_ERR_PARENT_TO_CHILD_COMM", WERR_FRS_ERR_PARENT_TO_CHILD_COMM },
+       { "WERR_FRS_ERR_SYSVOL_POPULATE", WERR_FRS_ERR_SYSVOL_POPULATE },
+       { "WERR_FRS_ERR_SYSVOL_POPULATE_TIMEOUT", WERR_FRS_ERR_SYSVOL_POPULATE_TIMEOUT },
+       { "WERR_FRS_ERR_SYSVOL_IS_BUSY", WERR_FRS_ERR_SYSVOL_IS_BUSY },
+       { "WERR_FRS_ERR_SYSVOL_DEMOTE", WERR_FRS_ERR_SYSVOL_DEMOTE },
+       { "WERR_FRS_ERR_INVALID_SERVICE_PARAMETER", WERR_FRS_ERR_INVALID_SERVICE_PARAMETER },
+       { "WERR_DS_NOT_INSTALLED", WERR_DS_NOT_INSTALLED },
+       { "WERR_DS_MEMBERSHIP_EVALUATED_LOCALLY", WERR_DS_MEMBERSHIP_EVALUATED_LOCALLY },
+       { "WERR_DS_INVALID_ATTRIBUTE_YNTAX", WERR_DS_INVALID_ATTRIBUTE_YNTAX },
+       { "WERR_DS_NO_RIDS_ALLOCATED", WERR_DS_NO_RIDS_ALLOCATED },
+       { "WERR_DS_NO_MORE_RIDS", WERR_DS_NO_MORE_RIDS },
+       { "WERR_DS_INCORRECT_ROLE_OWNER", WERR_DS_INCORRECT_ROLE_OWNER },
+       { "WERR_DS_RIDMGR_INIT_ERROR", WERR_DS_RIDMGR_INIT_ERROR },
+       { "WERR_DS_CROSS_DOM_MOVE_ERROR", WERR_DS_CROSS_DOM_MOVE_ERROR },
+       { "WERR_DS_GC_NOT_AVAILABLE", WERR_DS_GC_NOT_AVAILABLE },
+       { "WERR_SHARED_POLICY", WERR_SHARED_POLICY },
+       { "WERR_POLICY_OBJECT_NOT_FOUND", WERR_POLICY_OBJECT_NOT_FOUND },
+       { "WERR_POLICY_ONLY_IN_DS", WERR_POLICY_ONLY_IN_DS },
+       { "WERR_PROMOTION_ACTIVE", WERR_PROMOTION_ACTIVE },
+       { "WERR_NO_PROMOTION_ACTIVE", WERR_NO_PROMOTION_ACTIVE },
+       { "WERR_DS_SIZELIMIT_EXCEEDED", WERR_DS_SIZELIMIT_EXCEEDED },
+       { "WERR_DS_AUTH_UNKNOWN", WERR_DS_AUTH_UNKNOWN },
+       { "WERR_DS_IS_LEAF", WERR_DS_IS_LEAF },
+       { "WERR_DS_OBJECT_RESULTS_TOO_LARGE", WERR_DS_OBJECT_RESULTS_TOO_LARGE },
+       { "WERR_DS_SERVER_DOWN", WERR_DS_SERVER_DOWN },
+       { "WERR_DS_LOCAL_ERROR", WERR_DS_LOCAL_ERROR },
+       { "WERR_DS_ENCODING_ERROR", WERR_DS_ENCODING_ERROR },
+       { "WERR_DS_DECODING_ERROR", WERR_DS_DECODING_ERROR },
+       { "WERR_DS_FILTER_UNKNOWN", WERR_DS_FILTER_UNKNOWN },
+       { "WERR_DS_PARAM_ERROR", WERR_DS_PARAM_ERROR },
+       { "WERR_DS_NOT_SUPPORTED", WERR_DS_NOT_SUPPORTED },
+       { "WERR_DS_NO_RESULTS_RETURNED", WERR_DS_NO_RESULTS_RETURNED },
+       { "WERR_DS_CONTROL_NOT_FOUND", WERR_DS_CONTROL_NOT_FOUND },
+       { "WERR_DS_CLIENT_LOOP", WERR_DS_CLIENT_LOOP },
+       { "WERR_DS_REFERRAL_LIMIT_EXCEEDED", WERR_DS_REFERRAL_LIMIT_EXCEEDED },
+       { "WERR_DS_SORT_CONTROL_MISSING", WERR_DS_SORT_CONTROL_MISSING },
+       { "WERR_DS_OFFSET_RANGE_ERROR", WERR_DS_OFFSET_RANGE_ERROR },
+       { "WERR_DS_ROOT_MUST_BE_NC", WERR_DS_ROOT_MUST_BE_NC },
+       { "WERR_DS_ADD_REPLICA_INHIBITED", WERR_DS_ADD_REPLICA_INHIBITED },
+       { "WERR_DS_ATT_NOT_DEF_IN_SCHEMA", WERR_DS_ATT_NOT_DEF_IN_SCHEMA },
+       { "WERR_DS_MAX_OBJ_SIZE_EXCEEDED", WERR_DS_MAX_OBJ_SIZE_EXCEEDED },
+       { "WERR_DS_NO_RDN_DEFINED_IN_SCHEMA", WERR_DS_NO_RDN_DEFINED_IN_SCHEMA },
+       { "WERR_DS_RDN_DOESNT_MATCH_SCHEMA", WERR_DS_RDN_DOESNT_MATCH_SCHEMA },
+       { "WERR_DS_NO_REQUESTED_ATTS_FOUND", WERR_DS_NO_REQUESTED_ATTS_FOUND },
+       { "WERR_DS_USER_BUFFER_TO_SMALL", WERR_DS_USER_BUFFER_TO_SMALL },
+       { "WERR_DS_ATT_IS_NOT_ON_OBJ", WERR_DS_ATT_IS_NOT_ON_OBJ },
+       { "WERR_DS_ILLEGAL_MOD_OPERATION", WERR_DS_ILLEGAL_MOD_OPERATION },
+       { "WERR_DS_OBJ_TOO_LARGE", WERR_DS_OBJ_TOO_LARGE },
+       { "WERR_DS_BAD_INSTANCE_TYPE", WERR_DS_BAD_INSTANCE_TYPE },
+       { "WERR_DS_MASTERDSA_REQUIRED", WERR_DS_MASTERDSA_REQUIRED },
+       { "WERR_DS_OBJECT_CLASS_REQUIRED", WERR_DS_OBJECT_CLASS_REQUIRED },
+       { "WERR_DS_MISSING_REQUIRED_ATT", WERR_DS_MISSING_REQUIRED_ATT },
+       { "WERR_DS_ATT_NOT_DEF_FOR_CLASS", WERR_DS_ATT_NOT_DEF_FOR_CLASS },
+       { "WERR_DS_ATT_ALREADY_EXISTS", WERR_DS_ATT_ALREADY_EXISTS },
+       { "WERR_DS_CANT_ADD_ATT_VALUES", WERR_DS_CANT_ADD_ATT_VALUES },
+       { "WERR_DS_RANGE_CONSTRAINT", WERR_DS_RANGE_CONSTRAINT },
+       { "WERR_DS_ATT_VAL_ALREADY_EXISTS", WERR_DS_ATT_VAL_ALREADY_EXISTS },
+       { "WERR_DS_CANT_REM_MISSING_ATT", WERR_DS_CANT_REM_MISSING_ATT },
+       { "WERR_DS_CANT_REM_MISSING_ATT_VAL", WERR_DS_CANT_REM_MISSING_ATT_VAL },
+       { "WERR_DS_ROOT_CANT_BE_SUBREF", WERR_DS_ROOT_CANT_BE_SUBREF },
+       { "WERR_DS_NO_CHAINING", WERR_DS_NO_CHAINING },
+       { "WERR_DS_NO_CHAINED_EVAL", WERR_DS_NO_CHAINED_EVAL },
+       { "WERR_DS_NO_PARENT_OBJECT", WERR_DS_NO_PARENT_OBJECT },
+       { "WERR_DS_PARENT_IS_AN_ALIAS", WERR_DS_PARENT_IS_AN_ALIAS },
+       { "WERR_DS_CANT_MIX_MASTER_AND_REPS", WERR_DS_CANT_MIX_MASTER_AND_REPS },
+       { "WERR_DS_CHILDREN_EXIST", WERR_DS_CHILDREN_EXIST },
+       { "WERR_DS_ALIASED_OBJ_MISSING", WERR_DS_ALIASED_OBJ_MISSING },
+       { "WERR_DS_BAD_NAME_SYNTAX", WERR_DS_BAD_NAME_SYNTAX },
+       { "WERR_DS_ALIAS_POINTS_TO_ALIAS", WERR_DS_ALIAS_POINTS_TO_ALIAS },
+       { "WERR_DS_CANT_DEREF_ALIAS", WERR_DS_CANT_DEREF_ALIAS },
+       { "WERR_DS_OUT_OF_SCOPE", WERR_DS_OUT_OF_SCOPE },
+       { "WERR_DS_OBJECT_BEING_REMOVED", WERR_DS_OBJECT_BEING_REMOVED },
+       { "WERR_DS_CANT_DELETE_DSA_OBJ", WERR_DS_CANT_DELETE_DSA_OBJ },
+       { "WERR_DS_DSA_MUST_BE_INT_MASTER", WERR_DS_DSA_MUST_BE_INT_MASTER },
+       { "WERR_DS_CLASS_NOT_DSA", WERR_DS_CLASS_NOT_DSA },
+       { "WERR_DS_ILLEGAL_SUPERIOR", WERR_DS_ILLEGAL_SUPERIOR },
+       { "WERR_DS_ATTRIBUTE_OWNED_BY_SAM", WERR_DS_ATTRIBUTE_OWNED_BY_SAM },
+       { "WERR_DS_NAME_TOO_MANY_PARTS", WERR_DS_NAME_TOO_MANY_PARTS },
+       { "WERR_DS_NAME_TOO_LONG", WERR_DS_NAME_TOO_LONG },
+       { "WERR_DS_NAME_VALUE_TOO_LONG", WERR_DS_NAME_VALUE_TOO_LONG },
+       { "WERR_DS_NAME_UNPARSEABLE", WERR_DS_NAME_UNPARSEABLE },
+       { "WERR_DS_NAME_TYPE_UNKNOWN", WERR_DS_NAME_TYPE_UNKNOWN },
+       { "WERR_DS_NOT_AN_OBJECT", WERR_DS_NOT_AN_OBJECT },
+       { "WERR_DS_SEC_DESC_TOO_SHORT", WERR_DS_SEC_DESC_TOO_SHORT },
+       { "WERR_DS_SEC_DESC_INVALID", WERR_DS_SEC_DESC_INVALID },
+       { "WERR_DS_NO_DELETED_NAME", WERR_DS_NO_DELETED_NAME },
+       { "WERR_DS_SUBREF_MUST_HAVE_PARENT", WERR_DS_SUBREF_MUST_HAVE_PARENT },
+       { "WERR_DS_NCNAME_MUST_BE_NC", WERR_DS_NCNAME_MUST_BE_NC },
+       { "WERR_DS_CANT_ADD_SYSTEM_ONLY", WERR_DS_CANT_ADD_SYSTEM_ONLY },
+       { "WERR_DS_CLASS_MUST_BE_CONCRETE", WERR_DS_CLASS_MUST_BE_CONCRETE },
+       { "WERR_DS_INVALID_DMD", WERR_DS_INVALID_DMD },
+       { "WERR_DS_OBJ_GUID_EXISTS", WERR_DS_OBJ_GUID_EXISTS },
+       { "WERR_DS_NOT_ON_BACKLINK", WERR_DS_NOT_ON_BACKLINK },
+       { "WERR_DS_NO_CROSSREF_FOR_NC", WERR_DS_NO_CROSSREF_FOR_NC },
+       { "WERR_DS_SHUTTING_DOWN", WERR_DS_SHUTTING_DOWN },
+       { "WERR_DS_UNKNOWN_OPERATION", WERR_DS_UNKNOWN_OPERATION },
+       { "WERR_DS_INVALID_ROLE_OWNER", WERR_DS_INVALID_ROLE_OWNER },
+       { "WERR_DS_COULDNT_CONTACT_FSMO", WERR_DS_COULDNT_CONTACT_FSMO },
+       { "WERR_DS_CROSS_NC_DN_RENAME", WERR_DS_CROSS_NC_DN_RENAME },
+       { "WERR_DS_CANT_MOD_SYSTEM_ONLY", WERR_DS_CANT_MOD_SYSTEM_ONLY },
+       { "WERR_DS_REPLICATOR_ONLY", WERR_DS_REPLICATOR_ONLY },
+       { "WERR_DS_OBJ_CLASS_NOT_DEFINED", WERR_DS_OBJ_CLASS_NOT_DEFINED },
+       { "WERR_DS_OBJ_CLASS_NOT_SUBCLASS", WERR_DS_OBJ_CLASS_NOT_SUBCLASS },
+       { "WERR_DS_NAME_REFERENCE_INVALID", WERR_DS_NAME_REFERENCE_INVALID },
+       { "WERR_DS_CROSS_REF_EXISTS", WERR_DS_CROSS_REF_EXISTS },
+       { "WERR_DS_CANT_DEL_MASTER_CROSSREF", WERR_DS_CANT_DEL_MASTER_CROSSREF },
+       { "WERR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD", WERR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD },
+       { "WERR_DS_NOTIFY_FILTER_TOO_COMPLEX", WERR_DS_NOTIFY_FILTER_TOO_COMPLEX },
+       { "WERR_DS_DUP_RDN", WERR_DS_DUP_RDN },
+       { "WERR_DS_DUP_OID", WERR_DS_DUP_OID },
+       { "WERR_DS_DUP_MAPI_ID", WERR_DS_DUP_MAPI_ID },
+       { "WERR_DS_DUP_SCHEMA_ID_GUID", WERR_DS_DUP_SCHEMA_ID_GUID },
+       { "WERR_DS_DUP_LDAP_DISPLAY_NAME", WERR_DS_DUP_LDAP_DISPLAY_NAME },
+       { "WERR_DS_SEMANTIC_ATT_TEST", WERR_DS_SEMANTIC_ATT_TEST },
+       { "WERR_DS_SYNTAX_MISMATCH", WERR_DS_SYNTAX_MISMATCH },
+       { "WERR_DS_EXISTS_IN_MUST_HAVE", WERR_DS_EXISTS_IN_MUST_HAVE },
+       { "WERR_DS_EXISTS_IN_MAY_HAVE", WERR_DS_EXISTS_IN_MAY_HAVE },
+       { "WERR_DS_NONEXISTENT_MAY_HAVE", WERR_DS_NONEXISTENT_MAY_HAVE },
+       { "WERR_DS_NONEXISTENT_MUST_HAVE", WERR_DS_NONEXISTENT_MUST_HAVE },
+       { "WERR_DS_AUX_CLS_TEST_FAIL", WERR_DS_AUX_CLS_TEST_FAIL },
+       { "WERR_DS_NONEXISTENT_POSS_SUP", WERR_DS_NONEXISTENT_POSS_SUP },
+       { "WERR_DS_SUB_CLS_TEST_FAIL", WERR_DS_SUB_CLS_TEST_FAIL },
+       { "WERR_DS_BAD_RDN_ATT_ID_SYNTAX", WERR_DS_BAD_RDN_ATT_ID_SYNTAX },
+       { "WERR_DS_EXISTS_IN_AUX_CLS", WERR_DS_EXISTS_IN_AUX_CLS },
+       { "WERR_DS_EXISTS_IN_SUB_CLS", WERR_DS_EXISTS_IN_SUB_CLS },
+       { "WERR_DS_EXISTS_IN_POSS_SUP", WERR_DS_EXISTS_IN_POSS_SUP },
+       { "WERR_DS_RECALCSCHEMA_FAILED", WERR_DS_RECALCSCHEMA_FAILED },
+       { "WERR_DS_TREE_DELETE_NOT_FINISHED", WERR_DS_TREE_DELETE_NOT_FINISHED },
+       { "WERR_DS_CANT_DELETE", WERR_DS_CANT_DELETE },
+       { "WERR_DS_ATT_SCHEMA_REQ_ID", WERR_DS_ATT_SCHEMA_REQ_ID },
+       { "WERR_DS_BAD_ATT_SCHEMA_SYNTAX", WERR_DS_BAD_ATT_SCHEMA_SYNTAX },
+       { "WERR_DS_CANT_CACHE_ATT", WERR_DS_CANT_CACHE_ATT },
+       { "WERR_DS_CANT_CACHE_CLASS", WERR_DS_CANT_CACHE_CLASS },
+       { "WERR_DS_CANT_REMOVE_ATT_CACHE", WERR_DS_CANT_REMOVE_ATT_CACHE },
+       { "WERR_DS_CANT_REMOVE_CLASS_CACHE", WERR_DS_CANT_REMOVE_CLASS_CACHE },
+       { "WERR_DS_CANT_RETRIEVE_DN", WERR_DS_CANT_RETRIEVE_DN },
+       { "WERR_DS_MISSING_SUPREF", WERR_DS_MISSING_SUPREF },
+       { "WERR_DS_CANT_RETRIEVE_INSTANCE", WERR_DS_CANT_RETRIEVE_INSTANCE },
+       { "WERR_DS_CODE_INCONSISTENCY", WERR_DS_CODE_INCONSISTENCY },
+       { "WERR_DS_DATABASE_ERROR", WERR_DS_DATABASE_ERROR },
+       { "WERR_DS_MISSING_EXPECTED_ATT", WERR_DS_MISSING_EXPECTED_ATT },
+       { "WERR_DS_NCNAME_MISSING_CR_REF", WERR_DS_NCNAME_MISSING_CR_REF },
+       { "WERR_DS_SECURITY_CHECKING_ERROR", WERR_DS_SECURITY_CHECKING_ERROR },
+       { "WERR_DS_GCVERIFY_ERROR", WERR_DS_GCVERIFY_ERROR },
+       { "WERR_DS_CANT_FIND_DSA_OBJ", WERR_DS_CANT_FIND_DSA_OBJ },
+       { "WERR_DS_CANT_FIND_EXPECTED_NC", WERR_DS_CANT_FIND_EXPECTED_NC },
+       { "WERR_DS_CANT_FIND_NC_IN_CACHE", WERR_DS_CANT_FIND_NC_IN_CACHE },
+       { "WERR_DS_CANT_RETRIEVE_CHILD", WERR_DS_CANT_RETRIEVE_CHILD },
+       { "WERR_DS_SECURITY_ILLEGAL_MODIFY", WERR_DS_SECURITY_ILLEGAL_MODIFY },
+       { "WERR_DS_CANT_REPLACE_HIDDEN_REC", WERR_DS_CANT_REPLACE_HIDDEN_REC },
+       { "WERR_DS_BAD_HIERARCHY_FILE", WERR_DS_BAD_HIERARCHY_FILE },
+       { "WERR_DS_BUILD_HIERARCHY_TABLE_FAILED", WERR_DS_BUILD_HIERARCHY_TABLE_FAILED },
+       { "WERR_DS_CONFIG_PARAM_MISSING", WERR_DS_CONFIG_PARAM_MISSING },
+       { "WERR_DS_COUNTING_AB_INDICES_FAILED", WERR_DS_COUNTING_AB_INDICES_FAILED },
+       { "WERR_DS_HIERARCHY_TABLE_MALLOC_FAILED", WERR_DS_HIERARCHY_TABLE_MALLOC_FAILED },
+       { "WERR_DS_INTERNAL_FAILURE", WERR_DS_INTERNAL_FAILURE },
+       { "WERR_DS_UNKNOWN_ERROR", WERR_DS_UNKNOWN_ERROR },
+       { "WERR_DS_ROOT_REQUIRES_CLASS_TOP", WERR_DS_ROOT_REQUIRES_CLASS_TOP },
+       { "WERR_DS_REFUSING_FSMO_ROLES", WERR_DS_REFUSING_FSMO_ROLES },
+       { "WERR_DS_MISSING_FSMO_SETTINGS", WERR_DS_MISSING_FSMO_SETTINGS },
+       { "WERR_DS_UNABLE_TO_SURRENDER_ROLES", WERR_DS_UNABLE_TO_SURRENDER_ROLES },
+       { "WERR_DS_DRA_GENERIC", WERR_DS_DRA_GENERIC },
+       { "WERR_DS_DRA_BUSY", WERR_DS_DRA_BUSY },
+       { "WERR_DS_DRA_DN_EXISTS", WERR_DS_DRA_DN_EXISTS },
+       { "WERR_DS_DRA_INCONSISTENT_DIT", WERR_DS_DRA_INCONSISTENT_DIT },
+       { "WERR_DS_DRA_CONNECTION_FAILED", WERR_DS_DRA_CONNECTION_FAILED },
+       { "WERR_DS_DRA_BAD_INSTANCE_TYPE", WERR_DS_DRA_BAD_INSTANCE_TYPE },
+       { "WERR_DS_DRA_MAIL_PROBLEM", WERR_DS_DRA_MAIL_PROBLEM },
+       { "WERR_DS_DRA_REF_ALREADY_EXISTS", WERR_DS_DRA_REF_ALREADY_EXISTS },
+       { "WERR_DS_DRA_REF_NOT_FOUND", WERR_DS_DRA_REF_NOT_FOUND },
+       { "WERR_DS_DRA_OBJ_IS_REP_SOURCE", WERR_DS_DRA_OBJ_IS_REP_SOURCE },
+       { "WERR_DS_DRA_NOT_SUPPORTED", WERR_DS_DRA_NOT_SUPPORTED },
+       { "WERR_DS_DRA_RPC_CANCELLED", WERR_DS_DRA_RPC_CANCELLED },
+       { "WERR_DS_DRA_SINK_DISABLED", WERR_DS_DRA_SINK_DISABLED },
+       { "WERR_DS_DRA_NAME_COLLISION", WERR_DS_DRA_NAME_COLLISION },
+       { "WERR_DS_DRA_SOURCE_REINSTALLED", WERR_DS_DRA_SOURCE_REINSTALLED },
+       { "WERR_DS_DRA_MISSING_PARENT", WERR_DS_DRA_MISSING_PARENT },
+       { "WERR_DS_DRA_PREEMPTED", WERR_DS_DRA_PREEMPTED },
+       { "WERR_DS_DRA_ABANDON_SYNC", WERR_DS_DRA_ABANDON_SYNC },
+       { "WERR_DS_DRA_SHUTDOWN", WERR_DS_DRA_SHUTDOWN },
+       { "WERR_DS_DRA_INCOMPATIBLE_PARTIAL_SET", WERR_DS_DRA_INCOMPATIBLE_PARTIAL_SET },
+       { "WERR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA", WERR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA },
+       { "WERR_DS_DRA_EXTN_CONNECTION_FAILED", WERR_DS_DRA_EXTN_CONNECTION_FAILED },
+       { "WERR_DS_INSTALL_SCHEMA_MISMATCH", WERR_DS_INSTALL_SCHEMA_MISMATCH },
+       { "WERR_DS_DUP_LINK_ID", WERR_DS_DUP_LINK_ID },
+       { "WERR_DS_NAME_ERROR_RESOLVING", WERR_DS_NAME_ERROR_RESOLVING },
+       { "WERR_DS_NAME_ERROR_NOT_FOUND", WERR_DS_NAME_ERROR_NOT_FOUND },
+       { "WERR_DS_NAME_ERROR_NOT_UNIQUE", WERR_DS_NAME_ERROR_NOT_UNIQUE },
+       { "WERR_DS_NAME_ERROR_NO_MAPPING", WERR_DS_NAME_ERROR_NO_MAPPING },
+       { "WERR_DS_NAME_ERROR_DOMAIN_ONLY", WERR_DS_NAME_ERROR_DOMAIN_ONLY },
+       { "WERR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING", WERR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING },
+       { "WERR_DS_CONSTRUCTED_ATT_MOD", WERR_DS_CONSTRUCTED_ATT_MOD },
+       { "WERR_DS_WRONG_OM_OBJ_CLASS", WERR_DS_WRONG_OM_OBJ_CLASS },
+       { "WERR_DS_DRA_REPL_PENDING", WERR_DS_DRA_REPL_PENDING },
+       { "WERR_DS_DS_REQUIRED", WERR_DS_DS_REQUIRED },
+       { "WERR_DS_INVALID_LDAP_DISPLAY_NAME", WERR_DS_INVALID_LDAP_DISPLAY_NAME },
+       { "WERR_DS_NON_BASE_SEARCH", WERR_DS_NON_BASE_SEARCH },
+       { "WERR_DS_CANT_RETRIEVE_ATTS", WERR_DS_CANT_RETRIEVE_ATTS },
+       { "WERR_DS_BACKLINK_WITHOUT_LINK", WERR_DS_BACKLINK_WITHOUT_LINK },
+       { "WERR_DS_EPOCH_MISMATCH", WERR_DS_EPOCH_MISMATCH },
+       { "WERR_DS_SRC_NAME_MISMATCH", WERR_DS_SRC_NAME_MISMATCH },
+       { "WERR_DS_SRC_AND_DST_NC_IDENTICAL", WERR_DS_SRC_AND_DST_NC_IDENTICAL },
+       { "WERR_DS_DST_NC_MISMATCH", WERR_DS_DST_NC_MISMATCH },
+       { "WERR_DS_NOT_AUTHORITIVE_FOR_DST_NC", WERR_DS_NOT_AUTHORITIVE_FOR_DST_NC },
+       { "WERR_DS_SRC_GUID_MISMATCH", WERR_DS_SRC_GUID_MISMATCH },
+       { "WERR_DS_CANT_MOVE_DELETED_OBJECT", WERR_DS_CANT_MOVE_DELETED_OBJECT },
+       { "WERR_DS_PDC_OPERATION_IN_PROGRESS", WERR_DS_PDC_OPERATION_IN_PROGRESS },
+       { "WERR_DS_CROSS_DOMAIN_CLEANUP_REQD", WERR_DS_CROSS_DOMAIN_CLEANUP_REQD },
+       { "WERR_DS_ILLEGAL_XDOM_MOVE_OPERATION", WERR_DS_ILLEGAL_XDOM_MOVE_OPERATION },
+       { "WERR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS", WERR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS },
+       { "WERR_DS_NC_MUST_HAVE_NC_PARENT", WERR_DS_NC_MUST_HAVE_NC_PARENT },
+       { "WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE", WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE },
+       { "WERR_DS_DST_DOMAIN_NOT_NATIVE", WERR_DS_DST_DOMAIN_NOT_NATIVE },
+       { "WERR_DS_MISSING_INFRASTRUCTURE_CONTAINER", WERR_DS_MISSING_INFRASTRUCTURE_CONTAINER },
+       { "WERR_DS_CANT_MOVE_ACCOUNT_GROUP", WERR_DS_CANT_MOVE_ACCOUNT_GROUP },
+       { "WERR_DS_CANT_MOVE_RESOURCE_GROUP", WERR_DS_CANT_MOVE_RESOURCE_GROUP },
+       { "WERR_DS_INVALID_SEARCH_FLAG", WERR_DS_INVALID_SEARCH_FLAG },
+       { "WERR_DS_NO_TREE_DELETE_ABOVE_NC", WERR_DS_NO_TREE_DELETE_ABOVE_NC },
+       { "WERR_DS_COULDNT_LOCK_TREE_FOR_DELETE", WERR_DS_COULDNT_LOCK_TREE_FOR_DELETE },
+       { "WERR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE", WERR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE },
+       { "WERR_DS_SAM_INIT_FAILURE", WERR_DS_SAM_INIT_FAILURE },
+       { "WERR_DS_SENSITIVE_GROUP_VIOLATION", WERR_DS_SENSITIVE_GROUP_VIOLATION },
+       { "WERR_DS_CANT_MOD_PRIMARYGROUPID", WERR_DS_CANT_MOD_PRIMARYGROUPID },
+       { "WERR_DS_ILLEGAL_BASE_SCHEMA_MOD", WERR_DS_ILLEGAL_BASE_SCHEMA_MOD },
+       { "WERR_DS_NONSAFE_SCHEMA_CHANGE", WERR_DS_NONSAFE_SCHEMA_CHANGE },
+       { "WERR_DS_SCHEMA_UPDATE_DISALLOWED", WERR_DS_SCHEMA_UPDATE_DISALLOWED },
+       { "WERR_DS_CANT_CREATE_UNDER_SCHEMA", WERR_DS_CANT_CREATE_UNDER_SCHEMA },
+       { "WERR_DS_INVALID_GROUP_TYPE", WERR_DS_INVALID_GROUP_TYPE },
+       { "WERR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN", WERR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN },
+       { "WERR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN", WERR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN },
+       { "WERR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER", WERR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER },
+       { "WERR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER", WERR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER },
+       { "WERR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER", WERR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER },
+       { "WERR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER", WERR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER },
+       { "WERR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER", WERR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER },
+       { "WERR_DS_HAVE_PRIMARY_MEMBERS", WERR_DS_HAVE_PRIMARY_MEMBERS },
+       { "WERR_DS_STRING_SD_CONVERSION_FAILED", WERR_DS_STRING_SD_CONVERSION_FAILED },
+       { "WERR_DS_NAMING_MASTER_GC", WERR_DS_NAMING_MASTER_GC },
+       { "WERR_DS_COULDNT_UPDATE_SPNS", WERR_DS_COULDNT_UPDATE_SPNS },
+       { "WERR_DS_CANT_RETRIEVE_SD", WERR_DS_CANT_RETRIEVE_SD },
+       { "WERR_DS_KEY_NOT_UNIQUE", WERR_DS_KEY_NOT_UNIQUE },
+       { "WERR_DS_WRONG_LINKED_ATT_SYNTAX", WERR_DS_WRONG_LINKED_ATT_SYNTAX },
+       { "WERR_DS_SAM_NEED_BOOTKEY_PASSWORD", WERR_DS_SAM_NEED_BOOTKEY_PASSWORD },
+       { "WERR_DS_SAM_NEED_BOOTKEY_FLOPPY", WERR_DS_SAM_NEED_BOOTKEY_FLOPPY },
+       { "WERR_DS_CANT_START", WERR_DS_CANT_START },
+       { "WERR_DS_INIT_FAILURE", WERR_DS_INIT_FAILURE },
+       { "WERR_DS_NO_PKT_PRIVACY_ON_CONNECTION", WERR_DS_NO_PKT_PRIVACY_ON_CONNECTION },
+       { "WERR_DS_SOURCE_DOMAIN_IN_FOREST", WERR_DS_SOURCE_DOMAIN_IN_FOREST },
+       { "WERR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST", WERR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST },
+       { "WERR_DS_DESTINATION_AUDITING_NOT_ENABLED", WERR_DS_DESTINATION_AUDITING_NOT_ENABLED },
+       { "WERR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN", WERR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN },
+       { "WERR_DS_SRC_OBJ_NOT_GROUP_OR_USER", WERR_DS_SRC_OBJ_NOT_GROUP_OR_USER },
+       { "WERR_DS_SRC_SID_EXISTS_IN_FOREST", WERR_DS_SRC_SID_EXISTS_IN_FOREST },
+       { "WERR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH", WERR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH },
+       { "WERR_SAM_INIT_FAILURE", WERR_SAM_INIT_FAILURE },
+       { "WERR_DS_DRA_SCHEMA_INFO_SHIP", WERR_DS_DRA_SCHEMA_INFO_SHIP },
+       { "WERR_DS_DRA_SCHEMA_CONFLICT", WERR_DS_DRA_SCHEMA_CONFLICT },
+       { "WERR_DS_DRA_EARLIER_SCHEMA_CONFLICT", WERR_DS_DRA_EARLIER_SCHEMA_CONFLICT },
+       { "WERR_DS_DRA_OBJ_NC_MISMATCH", WERR_DS_DRA_OBJ_NC_MISMATCH },
+       { "WERR_DS_NC_STILL_HAS_DSAS", WERR_DS_NC_STILL_HAS_DSAS },
+       { "WERR_DS_GC_REQUIRED", WERR_DS_GC_REQUIRED },
+       { "WERR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY", WERR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY },
+       { "WERR_DS_NO_FPO_IN_UNIVERSAL_GROUPS", WERR_DS_NO_FPO_IN_UNIVERSAL_GROUPS },
+       { "WERR_DS_CANT_ADD_TO_GC", WERR_DS_CANT_ADD_TO_GC },
+       { "WERR_DS_NO_CHECKPOINT_WITH_PDC", WERR_DS_NO_CHECKPOINT_WITH_PDC },
+       { "WERR_DS_SOURCE_AUDITING_NOT_ENABLED", WERR_DS_SOURCE_AUDITING_NOT_ENABLED },
+       { "WERR_DS_CANT_CREATE_IN_NONDOMAIN_NC", WERR_DS_CANT_CREATE_IN_NONDOMAIN_NC },
+       { "WERR_DS_INVALID_NAME_FOR_SPN", WERR_DS_INVALID_NAME_FOR_SPN },
+       { "WERR_DS_FILTER_USES_CONTRUCTED_ATTRS", WERR_DS_FILTER_USES_CONTRUCTED_ATTRS },
+       { "WERR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED", WERR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED },
+       { "WERR_DS_MUST_BE_RUN_ON_DST_DC", WERR_DS_MUST_BE_RUN_ON_DST_DC },
+       { "WERR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER", WERR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER },
+       { "WERR_DS_CANT_TREE_DELETE_CRITICAL_OBJ", WERR_DS_CANT_TREE_DELETE_CRITICAL_OBJ },
+       { "WERR_DS_INIT_FAILURE_CONSOLE", WERR_DS_INIT_FAILURE_CONSOLE },
+       { "WERR_DS_SAM_INIT_FAILURE_CONSOLE", WERR_DS_SAM_INIT_FAILURE_CONSOLE },
+       { "WERR_DS_FOREST_VERSION_TOO_HIGH", WERR_DS_FOREST_VERSION_TOO_HIGH },
+       { "WERR_DS_DOMAIN_VERSION_TOO_HIGH", WERR_DS_DOMAIN_VERSION_TOO_HIGH },
+       { "WERR_DS_FOREST_VERSION_TOO_LOW", WERR_DS_FOREST_VERSION_TOO_LOW },
+       { "WERR_DS_DOMAIN_VERSION_TOO_LOW", WERR_DS_DOMAIN_VERSION_TOO_LOW },
+       { "WERR_DS_INCOMPATIBLE_VERSION", WERR_DS_INCOMPATIBLE_VERSION },
+       { "WERR_DS_LOW_DSA_VERSION", WERR_DS_LOW_DSA_VERSION },
+       { "WERR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN", WERR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN },
+       { "WERR_DS_NOT_SUPPORTED_SORT_ORDER", WERR_DS_NOT_SUPPORTED_SORT_ORDER },
+       { "WERR_DS_NAME_NOT_UNIQUE", WERR_DS_NAME_NOT_UNIQUE },
+       { "WERR_DS_MACHINE_ACCOUNT_CREATED_PRENT4", WERR_DS_MACHINE_ACCOUNT_CREATED_PRENT4 },
+       { "WERR_DS_OUT_OF_VERSION_STORE", WERR_DS_OUT_OF_VERSION_STORE },
+       { "WERR_DS_INCOMPATIBLE_CONTROLS_USED", WERR_DS_INCOMPATIBLE_CONTROLS_USED },
+       { "WERR_DS_NO_REF_DOMAIN", WERR_DS_NO_REF_DOMAIN },
+       { "WERR_DS_RESERVED_LINK_ID", WERR_DS_RESERVED_LINK_ID },
+       { "WERR_DS_LINK_ID_NOT_AVAILABLE", WERR_DS_LINK_ID_NOT_AVAILABLE },
+       { "WERR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER", WERR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER },
+       { "WERR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE", WERR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE },
+       { "WERR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC", WERR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC },
+       { "WERR_DS_MODIFYDN_DISALLOWED_BY_FLAG", WERR_DS_MODIFYDN_DISALLOWED_BY_FLAG },
+       { "WERR_DS_MODIFYDN_WRONG_GRANDPARENT", WERR_DS_MODIFYDN_WRONG_GRANDPARENT },
+       { "WERR_DS_NAME_ERROR_TRUST_REFERRAL", WERR_DS_NAME_ERROR_TRUST_REFERRAL },
+       { "WERR_NOT_SUPPORTED_ON_STANDARD_SERVER", WERR_NOT_SUPPORTED_ON_STANDARD_SERVER },
+       { "WERR_DS_CANT_ACCESS_REMOTE_PART_OF_AD", WERR_DS_CANT_ACCESS_REMOTE_PART_OF_AD },
+       { "WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2", WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2 },
+       { "WERR_DS_THREAD_LIMIT_EXCEEDED", WERR_DS_THREAD_LIMIT_EXCEEDED },
+       { "WERR_DS_NOT_CLOSEST", WERR_DS_NOT_CLOSEST },
+       { "WERR_DS_SINGLE_USER_MODE_FAILED", WERR_DS_SINGLE_USER_MODE_FAILED },
+       { "WERR_DS_NTDSCRIPT_SYNTAX_ERROR", WERR_DS_NTDSCRIPT_SYNTAX_ERROR },
+       { "WERR_DS_NTDSCRIPT_PROCESS_ERROR", WERR_DS_NTDSCRIPT_PROCESS_ERROR },
+       { "WERR_DS_DIFFERENT_REPL_EPOCHS", WERR_DS_DIFFERENT_REPL_EPOCHS },
+       { "WERR_DS_DRS_EXTENSIONS_CHANGED", WERR_DS_DRS_EXTENSIONS_CHANGED },
+       { "WERR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR", WERR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR },
+       { "WERR_DS_EXISTS_IN_RDNATTID", WERR_DS_EXISTS_IN_RDNATTID },
+       { "WERR_DS_AUTHORIZATION_FAILED", WERR_DS_AUTHORIZATION_FAILED },
+       { "WERR_DS_INVALID_SCRIPT", WERR_DS_INVALID_SCRIPT },
+       { "WERR_DS_REMOTE_CROSSREF_OP_FAILED", WERR_DS_REMOTE_CROSSREF_OP_FAILED },
+       { "WERR_DS_CROSS_REF_BUSY", WERR_DS_CROSS_REF_BUSY },
+       { "WERR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN", WERR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN },
+       { "WERR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC", WERR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC },
+       { "WERR_DS_DUPLICATE_ID_FOUND", WERR_DS_DUPLICATE_ID_FOUND },
+       { "WERR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT", WERR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT },
+       { "WERR_DS_GROUP_CONVERSION_ERROR", WERR_DS_GROUP_CONVERSION_ERROR },
+       { "WERR_DS_CANT_MOVE_APP_BASIC_GROUP", WERR_DS_CANT_MOVE_APP_BASIC_GROUP },
+       { "WERR_DS_CANT_MOVE_APP_QUERY_GROUP", WERR_DS_CANT_MOVE_APP_QUERY_GROUP },
+       { "WERR_DS_ROLE_NOT_VERIFIED", WERR_DS_ROLE_NOT_VERIFIED },
+       { "WERR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL", WERR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL },
+       { "WERR_DS_DOMAIN_RENAME_IN_PROGRESS", WERR_DS_DOMAIN_RENAME_IN_PROGRESS },
+       { "WERR_DS_EXISTING_AD_CHILD_NC", WERR_DS_EXISTING_AD_CHILD_NC },
+       { "WERR_DS_REPL_LIFETIME_EXCEEDED", WERR_DS_REPL_LIFETIME_EXCEEDED },
+       { "WERR_DS_DISALLOWED_IN_SYSTEM_CONTAINER", WERR_DS_DISALLOWED_IN_SYSTEM_CONTAINER },
+       { "WERR_DS_LDAP_SEND_QUEUE_FULL", WERR_DS_LDAP_SEND_QUEUE_FULL },
+       { "WERR_DS_DRA_OUT_SCHEDULE_WINDOW", WERR_DS_DRA_OUT_SCHEDULE_WINDOW },
+       { "WERR_DS_POLICY_NOT_KNOWN", WERR_DS_POLICY_NOT_KNOWN },
+       { "WERR_NO_SITE_SETTINGS_OBJECT", WERR_NO_SITE_SETTINGS_OBJECT },
+       { "WERR_NO_SECRETS", WERR_NO_SECRETS },
+       { "WERR_NO_WRITABLE_DC_FOUND", WERR_NO_WRITABLE_DC_FOUND },
+       { "WERR_DS_NO_SERVER_OBJECT", WERR_DS_NO_SERVER_OBJECT },
+       { "WERR_DS_NO_NTDSA_OBJECT", WERR_DS_NO_NTDSA_OBJECT },
+       { "WERR_DS_NON_ASQ_SEARCH", WERR_DS_NON_ASQ_SEARCH },
+       { "WERR_DS_AUDIT_FAILURE", WERR_DS_AUDIT_FAILURE },
+       { "WERR_DS_INVALID_SEARCH_FLAG_SUBTREE", WERR_DS_INVALID_SEARCH_FLAG_SUBTREE },
+       { "WERR_DS_INVALID_SEARCH_FLAG_TUPLE", WERR_DS_INVALID_SEARCH_FLAG_TUPLE },
+       { "WERR_IPSEC_QM_POLICY_EXISTS", WERR_IPSEC_QM_POLICY_EXISTS },
+       { "WERR_IPSEC_QM_POLICY_NOT_FOUND", WERR_IPSEC_QM_POLICY_NOT_FOUND },
+       { "WERR_IPSEC_QM_POLICY_IN_USE", WERR_IPSEC_QM_POLICY_IN_USE },
+       { "WERR_IPSEC_MM_POLICY_EXISTS", WERR_IPSEC_MM_POLICY_EXISTS },
+       { "WERR_IPSEC_MM_POLICY_NOT_FOUND", WERR_IPSEC_MM_POLICY_NOT_FOUND },
+       { "WERR_IPSEC_MM_POLICY_IN_USE", WERR_IPSEC_MM_POLICY_IN_USE },
+       { "WERR_IPSEC_MM_FILTER_EXISTS", WERR_IPSEC_MM_FILTER_EXISTS },
+       { "WERR_IPSEC_MM_FILTER_NOT_FOUND", WERR_IPSEC_MM_FILTER_NOT_FOUND },
+       { "WERR_IPSEC_TRANSPORT_FILTER_EXISTS", WERR_IPSEC_TRANSPORT_FILTER_EXISTS },
+       { "WERR_IPSEC_TRANSPORT_FILTER_NOT_FOUND", WERR_IPSEC_TRANSPORT_FILTER_NOT_FOUND },
+       { "WERR_IPSEC_MM_AUTH_EXISTS", WERR_IPSEC_MM_AUTH_EXISTS },
+       { "WERR_IPSEC_MM_AUTH_NOT_FOUND", WERR_IPSEC_MM_AUTH_NOT_FOUND },
+       { "WERR_IPSEC_MM_AUTH_IN_USE", WERR_IPSEC_MM_AUTH_IN_USE },
+       { "WERR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND", WERR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND },
+       { "WERR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND", WERR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND },
+       { "WERR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND", WERR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND },
+       { "WERR_IPSEC_TUNNEL_FILTER_EXISTS", WERR_IPSEC_TUNNEL_FILTER_EXISTS },
+       { "WERR_IPSEC_TUNNEL_FILTER_NOT_FOUND", WERR_IPSEC_TUNNEL_FILTER_NOT_FOUND },
+       { "WERR_IPSEC_MM_FILTER_PENDING_DELETION", WERR_IPSEC_MM_FILTER_PENDING_DELETION },
+       { "WERR_IPSEC_TRANSPORT_FILTER_ENDING_DELETION", WERR_IPSEC_TRANSPORT_FILTER_ENDING_DELETION },
+       { "WERR_IPSEC_TUNNEL_FILTER_PENDING_DELETION", WERR_IPSEC_TUNNEL_FILTER_PENDING_DELETION },
+       { "WERR_IPSEC_MM_POLICY_PENDING_ELETION", WERR_IPSEC_MM_POLICY_PENDING_ELETION },
+       { "WERR_IPSEC_MM_AUTH_PENDING_DELETION", WERR_IPSEC_MM_AUTH_PENDING_DELETION },
+       { "WERR_IPSEC_QM_POLICY_PENDING_DELETION", WERR_IPSEC_QM_POLICY_PENDING_DELETION },
+       { "WERR_IPSEC_IKE_NEG_STATUS_BEGIN", WERR_IPSEC_IKE_NEG_STATUS_BEGIN },
+       { "WERR_IPSEC_IKE_AUTH_FAIL", WERR_IPSEC_IKE_AUTH_FAIL },
+       { "WERR_IPSEC_IKE_ATTRIB_FAIL", WERR_IPSEC_IKE_ATTRIB_FAIL },
+       { "WERR_IPSEC_IKE_NEGOTIATION_PENDING", WERR_IPSEC_IKE_NEGOTIATION_PENDING },
+       { "WERR_IPSEC_IKE_GENERAL_PROCESSING_ERROR", WERR_IPSEC_IKE_GENERAL_PROCESSING_ERROR },
+       { "WERR_IPSEC_IKE_TIMED_OUT", WERR_IPSEC_IKE_TIMED_OUT },
+       { "WERR_IPSEC_IKE_NO_CERT", WERR_IPSEC_IKE_NO_CERT },
+       { "WERR_IPSEC_IKE_SA_DELETED", WERR_IPSEC_IKE_SA_DELETED },
+       { "WERR_IPSEC_IKE_SA_REAPED", WERR_IPSEC_IKE_SA_REAPED },
+       { "WERR_IPSEC_IKE_MM_ACQUIRE_DROP", WERR_IPSEC_IKE_MM_ACQUIRE_DROP },
+       { "WERR_IPSEC_IKE_QM_ACQUIRE_DROP", WERR_IPSEC_IKE_QM_ACQUIRE_DROP },
+       { "WERR_IPSEC_IKE_QUEUE_DROP_MM", WERR_IPSEC_IKE_QUEUE_DROP_MM },
+       { "WERR_IPSEC_IKE_QUEUE_DROP_NO_MM", WERR_IPSEC_IKE_QUEUE_DROP_NO_MM },
+       { "WERR_IPSEC_IKE_DROP_NO_RESPONSE", WERR_IPSEC_IKE_DROP_NO_RESPONSE },
+       { "WERR_IPSEC_IKE_MM_DELAY_DROP", WERR_IPSEC_IKE_MM_DELAY_DROP },
+       { "WERR_IPSEC_IKE_QM_DELAY_DROP", WERR_IPSEC_IKE_QM_DELAY_DROP },
+       { "WERR_IPSEC_IKE_ERROR", WERR_IPSEC_IKE_ERROR },
+       { "WERR_IPSEC_IKE_CRL_FAILED", WERR_IPSEC_IKE_CRL_FAILED },
+       { "WERR_IPSEC_IKE_INVALID_KEY_USAGE", WERR_IPSEC_IKE_INVALID_KEY_USAGE },
+       { "WERR_IPSEC_IKE_INVALID_CERT_TYPE", WERR_IPSEC_IKE_INVALID_CERT_TYPE },
+       { "WERR_IPSEC_IKE_NO_PRIVATE_KEY", WERR_IPSEC_IKE_NO_PRIVATE_KEY },
+       { "WERR_IPSEC_IKE_DH_FAIL", WERR_IPSEC_IKE_DH_FAIL },
+       { "WERR_IPSEC_IKE_INVALID_HEADER", WERR_IPSEC_IKE_INVALID_HEADER },
+       { "WERR_IPSEC_IKE_NO_POLICY", WERR_IPSEC_IKE_NO_POLICY },
+       { "WERR_IPSEC_IKE_INVALID_SIGNATURE", WERR_IPSEC_IKE_INVALID_SIGNATURE },
+       { "WERR_IPSEC_IKE_KERBEROS_ERROR", WERR_IPSEC_IKE_KERBEROS_ERROR },
+       { "WERR_IPSEC_IKE_NO_PUBLIC_KEY", WERR_IPSEC_IKE_NO_PUBLIC_KEY },
+       { "WERR_IPSEC_IKE_PROCESS_ERR", WERR_IPSEC_IKE_PROCESS_ERR },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_SA", WERR_IPSEC_IKE_PROCESS_ERR_SA },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_PROP", WERR_IPSEC_IKE_PROCESS_ERR_PROP },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_TRANS", WERR_IPSEC_IKE_PROCESS_ERR_TRANS },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_KE", WERR_IPSEC_IKE_PROCESS_ERR_KE },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_ID", WERR_IPSEC_IKE_PROCESS_ERR_ID },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_CERT", WERR_IPSEC_IKE_PROCESS_ERR_CERT },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_CERT_REQ", WERR_IPSEC_IKE_PROCESS_ERR_CERT_REQ },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_HASH", WERR_IPSEC_IKE_PROCESS_ERR_HASH },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_SIG", WERR_IPSEC_IKE_PROCESS_ERR_SIG },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_NONCE", WERR_IPSEC_IKE_PROCESS_ERR_NONCE },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_NOTIFY", WERR_IPSEC_IKE_PROCESS_ERR_NOTIFY },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_DELETE", WERR_IPSEC_IKE_PROCESS_ERR_DELETE },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_VENDOR", WERR_IPSEC_IKE_PROCESS_ERR_VENDOR },
+       { "WERR_IPSEC_IKE_INVALID_PAYLOAD", WERR_IPSEC_IKE_INVALID_PAYLOAD },
+       { "WERR_IPSEC_IKE_LOAD_SOFT_SA", WERR_IPSEC_IKE_LOAD_SOFT_SA },
+       { "WERR_IPSEC_IKE_SOFT_SA_TORN_DOWN", WERR_IPSEC_IKE_SOFT_SA_TORN_DOWN },
+       { "WERR_IPSEC_IKE_INVALID_COOKIE", WERR_IPSEC_IKE_INVALID_COOKIE },
+       { "WERR_IPSEC_IKE_NO_PEER_CERT", WERR_IPSEC_IKE_NO_PEER_CERT },
+       { "WERR_IPSEC_IKE_PEER_CRL_FAILED", WERR_IPSEC_IKE_PEER_CRL_FAILED },
+       { "WERR_IPSEC_IKE_POLICY_CHANGE", WERR_IPSEC_IKE_POLICY_CHANGE },
+       { "WERR_IPSEC_IKE_NO_MM_POLICY", WERR_IPSEC_IKE_NO_MM_POLICY },
+       { "WERR_IPSEC_IKE_NOTCBPRIV", WERR_IPSEC_IKE_NOTCBPRIV },
+       { "WERR_IPSEC_IKE_SECLOADFAIL", WERR_IPSEC_IKE_SECLOADFAIL },
+       { "WERR_IPSEC_IKE_FAILSSPINIT", WERR_IPSEC_IKE_FAILSSPINIT },
+       { "WERR_IPSEC_IKE_FAILQUERYSSP", WERR_IPSEC_IKE_FAILQUERYSSP },
+       { "WERR_IPSEC_IKE_SRVACQFAIL", WERR_IPSEC_IKE_SRVACQFAIL },
+       { "WERR_IPSEC_IKE_SRVQUERYCRED", WERR_IPSEC_IKE_SRVQUERYCRED },
+       { "WERR_IPSEC_IKE_GETSPIFAIL", WERR_IPSEC_IKE_GETSPIFAIL },
+       { "WERR_IPSEC_IKE_INVALID_FILTER", WERR_IPSEC_IKE_INVALID_FILTER },
+       { "WERR_IPSEC_IKE_OUT_OF_MEMORY", WERR_IPSEC_IKE_OUT_OF_MEMORY },
+       { "WERR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED", WERR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED },
+       { "WERR_IPSEC_IKE_INVALID_POLICY", WERR_IPSEC_IKE_INVALID_POLICY },
+       { "WERR_IPSEC_IKE_UNKNOWN_DOI", WERR_IPSEC_IKE_UNKNOWN_DOI },
+       { "WERR_IPSEC_IKE_INVALID_SITUATION", WERR_IPSEC_IKE_INVALID_SITUATION },
+       { "WERR_IPSEC_IKE_DH_FAILURE", WERR_IPSEC_IKE_DH_FAILURE },
+       { "WERR_IPSEC_IKE_INVALID_GROUP", WERR_IPSEC_IKE_INVALID_GROUP },
+       { "WERR_IPSEC_IKE_ENCRYPT", WERR_IPSEC_IKE_ENCRYPT },
+       { "WERR_IPSEC_IKE_DECRYPT", WERR_IPSEC_IKE_DECRYPT },
+       { "WERR_IPSEC_IKE_POLICY_MATCH", WERR_IPSEC_IKE_POLICY_MATCH },
+       { "WERR_IPSEC_IKE_UNSUPPORTED_ID", WERR_IPSEC_IKE_UNSUPPORTED_ID },
+       { "WERR_IPSEC_IKE_INVALID_HASH", WERR_IPSEC_IKE_INVALID_HASH },
+       { "WERR_IPSEC_IKE_INVALID_HASH_ALG", WERR_IPSEC_IKE_INVALID_HASH_ALG },
+       { "WERR_IPSEC_IKE_INVALID_HASH_SIZE", WERR_IPSEC_IKE_INVALID_HASH_SIZE },
+       { "WERR_IPSEC_IKE_INVALID_ENCRYPT_ALG", WERR_IPSEC_IKE_INVALID_ENCRYPT_ALG },
+       { "WERR_IPSEC_IKE_INVALID_AUTH_ALG", WERR_IPSEC_IKE_INVALID_AUTH_ALG },
+       { "WERR_IPSEC_IKE_INVALID_SIG", WERR_IPSEC_IKE_INVALID_SIG },
+       { "WERR_IPSEC_IKE_LOAD_FAILED", WERR_IPSEC_IKE_LOAD_FAILED },
+       { "WERR_IPSEC_IKE_RPC_DELETE", WERR_IPSEC_IKE_RPC_DELETE },
+       { "WERR_IPSEC_IKE_BENIGN_REINIT", WERR_IPSEC_IKE_BENIGN_REINIT },
+       { "WERR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY", WERR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY },
+       { "WERR_IPSEC_IKE_INVALID_CERT_KEYLEN", WERR_IPSEC_IKE_INVALID_CERT_KEYLEN },
+       { "WERR_IPSEC_IKE_MM_LIMIT", WERR_IPSEC_IKE_MM_LIMIT },
+       { "WERR_IPSEC_IKE_NEGOTIATION_DISABLED", WERR_IPSEC_IKE_NEGOTIATION_DISABLED },
+       { "WERR_IPSEC_IKE_QM_LIMIT", WERR_IPSEC_IKE_QM_LIMIT },
+       { "WERR_IPSEC_IKE_MM_EXPIRED", WERR_IPSEC_IKE_MM_EXPIRED },
+       { "WERR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID", WERR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID },
+       { "WERR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH", WERR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH },
+       { "WERR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID", WERR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID },
+       { "WERR_IPSEC_IKE_INVALID_UMATTS", WERR_IPSEC_IKE_INVALID_UMATTS },
+       { "WERR_IPSEC_IKE_DOS_COOKIE_SENT", WERR_IPSEC_IKE_DOS_COOKIE_SENT },
+       { "WERR_IPSEC_IKE_SHUTTING_DOWN", WERR_IPSEC_IKE_SHUTTING_DOWN },
+       { "WERR_IPSEC_IKE_CGA_AUTH_FAILED", WERR_IPSEC_IKE_CGA_AUTH_FAILED },
+       { "WERR_IPSEC_IKE_PROCESS_ERR_NATOA", WERR_IPSEC_IKE_PROCESS_ERR_NATOA },
+       { "WERR_IPSEC_IKE_INVALID_MM_FOR_QM", WERR_IPSEC_IKE_INVALID_MM_FOR_QM },
+       { "WERR_IPSEC_IKE_QM_EXPIRED", WERR_IPSEC_IKE_QM_EXPIRED },
+       { "WERR_IPSEC_IKE_TOO_MANY_FILTERS", WERR_IPSEC_IKE_TOO_MANY_FILTERS },
+       { "WERR_IPSEC_IKE_NEG_STATUS_END", WERR_IPSEC_IKE_NEG_STATUS_END },
+       { "WERR_SXS_SECTION_NOT_FOUND", WERR_SXS_SECTION_NOT_FOUND },
+       { "WERR_SXS_CANT_GEN_ACTCTX", WERR_SXS_CANT_GEN_ACTCTX },
+       { "WERR_SXS_INVALID_ACTCTXDATA_FORMAT", WERR_SXS_INVALID_ACTCTXDATA_FORMAT },
+       { "WERR_SXS_ASSEMBLY_NOT_FOUND", WERR_SXS_ASSEMBLY_NOT_FOUND },
+       { "WERR_SXS_MANIFEST_FORMAT_ERROR", WERR_SXS_MANIFEST_FORMAT_ERROR },
+       { "WERR_SXS_MANIFEST_PARSE_ERROR", WERR_SXS_MANIFEST_PARSE_ERROR },
+       { "WERR_SXS_ACTIVATION_CONTEXT_DISABLED", WERR_SXS_ACTIVATION_CONTEXT_DISABLED },
+       { "WERR_SXS_KEY_NOT_FOUND", WERR_SXS_KEY_NOT_FOUND },
+       { "WERR_SXS_VERSION_CONFLICT", WERR_SXS_VERSION_CONFLICT },
+       { "WERR_SXS_WRONG_SECTION_TYPE", WERR_SXS_WRONG_SECTION_TYPE },
+       { "WERR_SXS_THREAD_QUERIES_DISABLED", WERR_SXS_THREAD_QUERIES_DISABLED },
+       { "WERR_SXS_PROCESS_DEFAULT_ALREADY_SET", WERR_SXS_PROCESS_DEFAULT_ALREADY_SET },
+       { "WERR_SXS_UNKNOWN_ENCODING_GROUP", WERR_SXS_UNKNOWN_ENCODING_GROUP },
+       { "WERR_SXS_UNKNOWN_ENCODING", WERR_SXS_UNKNOWN_ENCODING },
+       { "WERR_SXS_INVALID_XML_NAMESPACE_URI", WERR_SXS_INVALID_XML_NAMESPACE_URI },
+       { "WERR_SXS_ROOT_MANIFEST_DEPENDENCY_OT_INSTALLED", WERR_SXS_ROOT_MANIFEST_DEPENDENCY_OT_INSTALLED },
+       { "WERR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED", WERR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED },
+       { "WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE", WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE },
+       { "WERR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE", WERR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE },
+       { "WERR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE", WERR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE },
+       { "WERR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT", WERR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT },
+       { "WERR_SXS_DUPLICATE_DLL_NAME", WERR_SXS_DUPLICATE_DLL_NAME },
+       { "WERR_SXS_DUPLICATE_WINDOWCLASS_NAME", WERR_SXS_DUPLICATE_WINDOWCLASS_NAME },
+       { "WERR_SXS_DUPLICATE_CLSID", WERR_SXS_DUPLICATE_CLSID },
+       { "WERR_SXS_DUPLICATE_IID", WERR_SXS_DUPLICATE_IID },
+       { "WERR_SXS_DUPLICATE_TLBID", WERR_SXS_DUPLICATE_TLBID },
+       { "WERR_SXS_DUPLICATE_PROGID", WERR_SXS_DUPLICATE_PROGID },
+       { "WERR_SXS_DUPLICATE_ASSEMBLY_NAME", WERR_SXS_DUPLICATE_ASSEMBLY_NAME },
+       { "WERR_SXS_FILE_HASH_MISMATCH", WERR_SXS_FILE_HASH_MISMATCH },
+       { "WERR_SXS_POLICY_PARSE_ERROR", WERR_SXS_POLICY_PARSE_ERROR },
+       { "WERR_SXS_XML_E_MISSINGQUOTE", WERR_SXS_XML_E_MISSINGQUOTE },
+       { "WERR_SXS_XML_E_COMMENTSYNTAX", WERR_SXS_XML_E_COMMENTSYNTAX },
+       { "WERR_SXS_XML_E_BADSTARTNAMECHAR", WERR_SXS_XML_E_BADSTARTNAMECHAR },
+       { "WERR_SXS_XML_E_BADNAMECHAR", WERR_SXS_XML_E_BADNAMECHAR },
+       { "WERR_SXS_XML_E_BADCHARINSTRING", WERR_SXS_XML_E_BADCHARINSTRING },
+       { "WERR_SXS_XML_E_XMLDECLSYNTAX", WERR_SXS_XML_E_XMLDECLSYNTAX },
+       { "WERR_SXS_XML_E_BADCHARDATA", WERR_SXS_XML_E_BADCHARDATA },
+       { "WERR_SXS_XML_E_MISSINGWHITESPACE", WERR_SXS_XML_E_MISSINGWHITESPACE },
+       { "WERR_SXS_XML_E_EXPECTINGTAGEND", WERR_SXS_XML_E_EXPECTINGTAGEND },
+       { "WERR_SXS_XML_E_MISSINGSEMICOLON", WERR_SXS_XML_E_MISSINGSEMICOLON },
+       { "WERR_SXS_XML_E_UNBALANCEDPAREN", WERR_SXS_XML_E_UNBALANCEDPAREN },
+       { "WERR_SXS_XML_E_INTERNALERROR", WERR_SXS_XML_E_INTERNALERROR },
+       { "WERR_SXS_XML_E_UNEXPECTED_WHITESPACE", WERR_SXS_XML_E_UNEXPECTED_WHITESPACE },
+       { "WERR_SXS_XML_E_INCOMPLETE_ENCODING", WERR_SXS_XML_E_INCOMPLETE_ENCODING },
+       { "WERR_SXS_XML_E_MISSING_PAREN", WERR_SXS_XML_E_MISSING_PAREN },
+       { "WERR_SXS_XML_E_EXPECTINGCLOSEQUOTE", WERR_SXS_XML_E_EXPECTINGCLOSEQUOTE },
+       { "WERR_SXS_XML_E_MULTIPLE_COLONS", WERR_SXS_XML_E_MULTIPLE_COLONS },
+       { "WERR_SXS_XML_E_INVALID_DECIMAL", WERR_SXS_XML_E_INVALID_DECIMAL },
+       { "WERR_SXS_XML_E_INVALID_HEXIDECIMAL", WERR_SXS_XML_E_INVALID_HEXIDECIMAL },
+       { "WERR_SXS_XML_E_INVALID_UNICODE", WERR_SXS_XML_E_INVALID_UNICODE },
+       { "WERR_SXS_XML_E_WHITESPACEORQUESTIONMARK", WERR_SXS_XML_E_WHITESPACEORQUESTIONMARK },
+       { "WERR_SXS_XML_E_UNEXPECTEDENDTAG", WERR_SXS_XML_E_UNEXPECTEDENDTAG },
+       { "WERR_SXS_XML_E_UNCLOSEDTAG", WERR_SXS_XML_E_UNCLOSEDTAG },
+       { "WERR_SXS_XML_E_DUPLICATEATTRIBUTE", WERR_SXS_XML_E_DUPLICATEATTRIBUTE },
+       { "WERR_SXS_XML_E_MULTIPLEROOTS", WERR_SXS_XML_E_MULTIPLEROOTS },
+       { "WERR_SXS_XML_E_INVALIDATROOTLEVEL", WERR_SXS_XML_E_INVALIDATROOTLEVEL },
+       { "WERR_SXS_XML_E_BADXMLDECL", WERR_SXS_XML_E_BADXMLDECL },
+       { "WERR_SXS_XML_E_MISSINGROOT", WERR_SXS_XML_E_MISSINGROOT },
+       { "WERR_SXS_XML_E_UNEXPECTEDEOF", WERR_SXS_XML_E_UNEXPECTEDEOF },
+       { "WERR_SXS_XML_E_BADPEREFINSUBSET", WERR_SXS_XML_E_BADPEREFINSUBSET },
+       { "WERR_SXS_XML_E_UNCLOSEDSTARTTAG", WERR_SXS_XML_E_UNCLOSEDSTARTTAG },
+       { "WERR_SXS_XML_E_UNCLOSEDENDTAG", WERR_SXS_XML_E_UNCLOSEDENDTAG },
+       { "WERR_SXS_XML_E_UNCLOSEDSTRING", WERR_SXS_XML_E_UNCLOSEDSTRING },
+       { "WERR_SXS_XML_E_UNCLOSEDCOMMENT", WERR_SXS_XML_E_UNCLOSEDCOMMENT },
+       { "WERR_SXS_XML_E_UNCLOSEDDECL", WERR_SXS_XML_E_UNCLOSEDDECL },
+       { "WERR_SXS_XML_E_UNCLOSEDCDATA", WERR_SXS_XML_E_UNCLOSEDCDATA },
+       { "WERR_SXS_XML_E_RESERVEDNAMESPACE", WERR_SXS_XML_E_RESERVEDNAMESPACE },
+       { "WERR_SXS_XML_E_INVALIDENCODING", WERR_SXS_XML_E_INVALIDENCODING },
+       { "WERR_SXS_XML_E_INVALIDSWITCH", WERR_SXS_XML_E_INVALIDSWITCH },
+       { "WERR_SXS_XML_E_BADXMLCASE", WERR_SXS_XML_E_BADXMLCASE },
+       { "WERR_SXS_XML_E_INVALID_STANDALONE", WERR_SXS_XML_E_INVALID_STANDALONE },
+       { "WERR_SXS_XML_E_UNEXPECTED_STANDALONE", WERR_SXS_XML_E_UNEXPECTED_STANDALONE },
+       { "WERR_SXS_XML_E_INVALID_VERSION", WERR_SXS_XML_E_INVALID_VERSION },
+       { "WERR_SXS_XML_E_MISSINGEQUALS", WERR_SXS_XML_E_MISSINGEQUALS },
+       { "WERR_SXS_PROTECTION_RECOVERY_FAILED", WERR_SXS_PROTECTION_RECOVERY_FAILED },
+       { "WERR_SXS_PROTECTION_PUBLIC_KEY_OO_SHORT", WERR_SXS_PROTECTION_PUBLIC_KEY_OO_SHORT },
+       { "WERR_SXS_PROTECTION_CATALOG_NOT_VALID", WERR_SXS_PROTECTION_CATALOG_NOT_VALID },
+       { "WERR_SXS_UNTRANSLATABLE_HRESULT", WERR_SXS_UNTRANSLATABLE_HRESULT },
+       { "WERR_SXS_PROTECTION_CATALOG_FILE_MISSING", WERR_SXS_PROTECTION_CATALOG_FILE_MISSING },
+       { "WERR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE", WERR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE },
+       { "WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME", WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME },
+       { "WERR_SXS_ASSEMBLY_MISSING", WERR_SXS_ASSEMBLY_MISSING },
+       { "WERR_SXS_CORRUPT_ACTIVATION_STACK", WERR_SXS_CORRUPT_ACTIVATION_STACK },
+       { "WERR_SXS_CORRUPTION", WERR_SXS_CORRUPTION },
+       { "WERR_SXS_EARLY_DEACTIVATION", WERR_SXS_EARLY_DEACTIVATION },
+       { "WERR_SXS_INVALID_DEACTIVATION", WERR_SXS_INVALID_DEACTIVATION },
+       { "WERR_SXS_MULTIPLE_DEACTIVATION", WERR_SXS_MULTIPLE_DEACTIVATION },
+       { "WERR_SXS_PROCESS_TERMINATION_REQUESTED", WERR_SXS_PROCESS_TERMINATION_REQUESTED },
+       { "WERR_SXS_RELEASE_ACTIVATION_ONTEXT", WERR_SXS_RELEASE_ACTIVATION_ONTEXT },
+       { "WERR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY", WERR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY },
+       { "WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE", WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE },
+       { "WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME", WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME },
+       { "WERR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE", WERR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE },
+       { "WERR_SXS_IDENTITY_PARSE_ERROR", WERR_SXS_IDENTITY_PARSE_ERROR },
+       { "WERR_MALFORMED_SUBSTITUTION_STRING", WERR_MALFORMED_SUBSTITUTION_STRING },
+       { "WERR_SXS_INCORRECT_PUBLIC_KEY_OKEN", WERR_SXS_INCORRECT_PUBLIC_KEY_OKEN },
+       { "WERR_UNMAPPED_SUBSTITUTION_STRING", WERR_UNMAPPED_SUBSTITUTION_STRING },
+       { "WERR_SXS_ASSEMBLY_NOT_LOCKED", WERR_SXS_ASSEMBLY_NOT_LOCKED },
+       { "WERR_SXS_COMPONENT_STORE_CORRUPT", WERR_SXS_COMPONENT_STORE_CORRUPT },
+       { "WERR_ADVANCED_INSTALLER_FAILED", WERR_ADVANCED_INSTALLER_FAILED },
+       { "WERR_XML_ENCODING_MISMATCH", WERR_XML_ENCODING_MISMATCH },
+       { "WERR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT", WERR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT },
+       { "WERR_SXS_IDENTITIES_DIFFERENT", WERR_SXS_IDENTITIES_DIFFERENT },
+       { "WERR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT", WERR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT },
+       { "WERR_SXS_FILE_NOT_PART_OF_ASSEMBLY", WERR_SXS_FILE_NOT_PART_OF_ASSEMBLY },
+       { "WERR_SXS_MANIFEST_TOO_BIG", WERR_SXS_MANIFEST_TOO_BIG },
+       { "WERR_SXS_SETTING_NOT_REGISTERED", WERR_SXS_SETTING_NOT_REGISTERED },
+       { "WERR_SXS_TRANSACTION_CLOSURE_INCOMPLETE", WERR_SXS_TRANSACTION_CLOSURE_INCOMPLETE },
+       { "WERR_EVT_INVALID_CHANNEL_PATH", WERR_EVT_INVALID_CHANNEL_PATH },
+       { "WERR_EVT_INVALID_QUERY", WERR_EVT_INVALID_QUERY },
+       { "WERR_EVT_PUBLISHER_METADATA_NOT_FOUND", WERR_EVT_PUBLISHER_METADATA_NOT_FOUND },
+       { "WERR_EVT_EVENT_TEMPLATE_NOT_FOUND", WERR_EVT_EVENT_TEMPLATE_NOT_FOUND },
+       { "WERR_EVT_INVALID_PUBLISHER_NAME", WERR_EVT_INVALID_PUBLISHER_NAME },
+       { "WERR_EVT_INVALID_EVENT_DATA", WERR_EVT_INVALID_EVENT_DATA },
+       { "WERR_EVT_CHANNEL_NOT_FOUND", WERR_EVT_CHANNEL_NOT_FOUND },
+       { "WERR_EVT_MALFORMED_XML_TEXT", WERR_EVT_MALFORMED_XML_TEXT },
+       { "WERR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL", WERR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL },
+       { "WERR_EVT_CONFIGURATION_ERROR", WERR_EVT_CONFIGURATION_ERROR },
+       { "WERR_EVT_QUERY_RESULT_STALE", WERR_EVT_QUERY_RESULT_STALE },
+       { "WERR_EVT_QUERY_RESULT_INVALID_POSITION", WERR_EVT_QUERY_RESULT_INVALID_POSITION },
+       { "WERR_EVT_NON_VALIDATING_MSXML", WERR_EVT_NON_VALIDATING_MSXML },
+       { "WERR_EVT_FILTER_ALREADYSCOPED", WERR_EVT_FILTER_ALREADYSCOPED },
+       { "WERR_EVT_FILTER_NOTELTSET", WERR_EVT_FILTER_NOTELTSET },
+       { "WERR_EVT_FILTER_INVARG", WERR_EVT_FILTER_INVARG },
+       { "WERR_EVT_FILTER_INVTEST", WERR_EVT_FILTER_INVTEST },
+       { "WERR_EVT_FILTER_INVTYPE", WERR_EVT_FILTER_INVTYPE },
+       { "WERR_EVT_FILTER_PARSEERR", WERR_EVT_FILTER_PARSEERR },
+       { "WERR_EVT_FILTER_UNSUPPORTEDOP", WERR_EVT_FILTER_UNSUPPORTEDOP },
+       { "WERR_EVT_FILTER_UNEXPECTEDTOKEN", WERR_EVT_FILTER_UNEXPECTEDTOKEN },
+       { "WERR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL", WERR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL },
+       { "WERR_EVT_INVALID_CHANNEL_PROPERTY_VALUE", WERR_EVT_INVALID_CHANNEL_PROPERTY_VALUE },
+       { "WERR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE", WERR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE },
+       { "WERR_EVT_CHANNEL_CANNOT_ACTIVATE", WERR_EVT_CHANNEL_CANNOT_ACTIVATE },
+       { "WERR_EVT_FILTER_TOO_COMPLEX", WERR_EVT_FILTER_TOO_COMPLEX },
+       { "WERR_EVT_MESSAGE_NOT_FOUND", WERR_EVT_MESSAGE_NOT_FOUND },
+       { "WERR_EVT_MESSAGE_ID_NOT_FOUND", WERR_EVT_MESSAGE_ID_NOT_FOUND },
+       { "WERR_EVT_UNRESOLVED_VALUE_INSERT", WERR_EVT_UNRESOLVED_VALUE_INSERT },
+       { "WERR_EVT_UNRESOLVED_PARAMETER_INSERT", WERR_EVT_UNRESOLVED_PARAMETER_INSERT },
+       { "WERR_EVT_MAX_INSERTS_REACHED", WERR_EVT_MAX_INSERTS_REACHED },
+       { "WERR_EVT_EVENT_DEFINITION_NOT_OUND", WERR_EVT_EVENT_DEFINITION_NOT_OUND },
+       { "WERR_EVT_MESSAGE_LOCALE_NOT_FOUND", WERR_EVT_MESSAGE_LOCALE_NOT_FOUND },
+       { "WERR_EVT_VERSION_TOO_OLD", WERR_EVT_VERSION_TOO_OLD },
+       { "WERR_EVT_VERSION_TOO_NEW", WERR_EVT_VERSION_TOO_NEW },
+       { "WERR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY", WERR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY },
+       { "WERR_EVT_PUBLISHER_DISABLED", WERR_EVT_PUBLISHER_DISABLED },
+       { "WERR_EC_SUBSCRIPTION_CANNOT_ACTIVATE", WERR_EC_SUBSCRIPTION_CANNOT_ACTIVATE },
+       { "WERR_EC_LOG_DISABLED", WERR_EC_LOG_DISABLED },
+       { "WERR_MUI_FILE_NOT_FOUND", WERR_MUI_FILE_NOT_FOUND },
+       { "WERR_MUI_INVALID_FILE", WERR_MUI_INVALID_FILE },
+       { "WERR_MUI_INVALID_RC_CONFIG", WERR_MUI_INVALID_RC_CONFIG },
+       { "WERR_MUI_INVALID_LOCALE_NAME", WERR_MUI_INVALID_LOCALE_NAME },
+       { "WERR_MUI_INVALID_ULTIMATEFALLBACK_NAME", WERR_MUI_INVALID_ULTIMATEFALLBACK_NAME },
+       { "WERR_MUI_FILE_NOT_LOADED", WERR_MUI_FILE_NOT_LOADED },
+       { "WERR_RESOURCE_ENUM_USER_STOP", WERR_RESOURCE_ENUM_USER_STOP },
+       { "WERR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED", WERR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED },
+       { "WERR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME", WERR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME },
+       { "WERR_MCA_INVALID_CAPABILITIES_STRING", WERR_MCA_INVALID_CAPABILITIES_STRING },
+       { "WERR_MCA_INVALID_VCP_VERSION", WERR_MCA_INVALID_VCP_VERSION },
+       { "WERR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION", WERR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION },
+       { "WERR_MCA_MCCS_VERSION_MISMATCH", WERR_MCA_MCCS_VERSION_MISMATCH },
+       { "WERR_MCA_UNSUPPORTED_MCCS_VERSION", WERR_MCA_UNSUPPORTED_MCCS_VERSION },
+       { "WERR_MCA_INTERNAL_ERROR", WERR_MCA_INTERNAL_ERROR },
+       { "WERR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED", WERR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED },
+       { "WERR_MCA_UNSUPPORTED_COLOR_TEMPERATURE", WERR_MCA_UNSUPPORTED_COLOR_TEMPERATURE },
+       { "WERR_AMBIGUOUS_SYSTEM_DEVICE", WERR_AMBIGUOUS_SYSTEM_DEVICE },
+       { "WERR_SYSTEM_DEVICE_NOT_FOUND", WERR_SYSTEM_DEVICE_NOT_FOUND },
+       /* END GENERATED-WIN32-ERROR-CODES */
        { NULL, W_ERROR(0) }
 };
 
@@ -260,12 +2620,12 @@ const struct werror_str_struct dos_err_strs[] = {
        { WERR_NO_LOGON_SERVERS, "No logon servers found" },
        { WERR_NO_SUCH_LOGON_SESSION, "No such logon session" },
        { WERR_DOMAIN_CONTROLLER_NOT_FOUND, "A domain controller could not be found" },
-       { WERR_DC_NOT_FOUND, "A domain controller could not be found" },
+       { WERR_DCNOTFOUND, "A domain controller could not be found" },
        { WERR_SETUP_NOT_JOINED, "Join failed" },
        { WERR_SETUP_ALREADY_JOINED, "Machine is already joined" },
        { WERR_SETUP_DOMAIN_CONTROLLER, "Machine is a Domain Controller" },
        { WERR_LOGON_FAILURE, "Invalid logon credentials" },
-       { WERR_USER_EXISTS, "User account already exists" },
+       { WERR_USEREXISTS, "The user account already exists." },
        { WERR_PASSWORD_MUST_CHANGE, "The password must be changed" },
        { WERR_ACCOUNT_LOCKED_OUT, "Account locked out" },
        { WERR_TIME_SKEW, "Time difference between client and server" },
@@ -278,7 +2638,2507 @@ const struct werror_str_struct dos_err_strs[] = {
        { WERR_INVALID_PRIMARY_GROUP, "The account's primary group is invalid" },
        { WERR_DS_DRA_BAD_DN, "An invalid distinguished name was specified for this replication" },
        { WERR_DS_DRA_BAD_NC, "An invalid naming context was specified for this replication operation" },
-       { WERR_WRONG_PASSWORD, "The current password is incorrect" }
+       { WERR_WRONG_PASSWORD, "The current password is incorrect" },
+       /*****************************************************************************
+        Auto-generated Win32 error from:
+        http://msdn.microsoft.com/en-us/library/cc231199%28PROT.10%29.aspx
+        *****************************************************************************/
+       /* BEGIN GENERATED-WIN32-ERROR-CODES-DESC */
+       { WERR_NERR_SUCCESS, "The operation completed successfully." },
+       { WERR_INVALID_FUNCTION, "Incorrect function." },
+       { WERR_FILE_NOT_FOUND, "The system cannot find the file specified." },
+       { WERR_PATH_NOT_FOUND, "The system cannot find the path specified." },
+       { WERR_TOO_MANY_OPEN_FILES, "The system cannot open the file." },
+       { WERR_ACCESS_DENIED, "Access is denied." },
+       { WERR_INVALID_HANDLE, "The handle is invalid." },
+       { WERR_ARENA_TRASHED, "The storage control blocks were destroyed." },
+       { WERR_NOT_ENOUGH_MEMORY, "Not enough storage is available to process this command." },
+       { WERR_INVALID_BLOCK, "The storage control block address is invalid." },
+       { WERR_BAD_ENVIRONMENT, "The environment is incorrect." },
+       { WERR_BAD_FORMAT, "An attempt was made to load a program with an incorrect format." },
+       { WERR_INVALID_ACCESS, "The access code is invalid." },
+       { WERR_INVALID_DATA, "The data is invalid." },
+       { WERR_OUTOFMEMORY, "Not enough storage is available to complete this operation." },
+       { WERR_INVALID_DRIVE, "The system cannot find the drive specified." },
+       { WERR_CURRENT_DIRECTORY, "The directory cannot be removed." },
+       { WERR_NOT_SAME_DEVICE, "The system cannot move the file to a different disk drive." },
+       { WERR_NO_MORE_FILES, "There are no more files." },
+       { WERR_WRITE_PROTECT, "The media is write-protected." },
+       { WERR_BAD_UNIT, "The system cannot find the device specified." },
+       { WERR_NOT_READY, "The device is not ready." },
+       { WERR_BAD_COMMAND, "The device does not recognize the command." },
+       { WERR_CRC, "Data error (cyclic redundancy check)." },
+       { WERR_BAD_LENGTH, "The program issued a command but the command length is incorrect." },
+       { WERR_SEEK, "The drive cannot locate a specific area or track on the disk." },
+       { WERR_NOT_DOS_DISK, "The specified disk cannot be accessed." },
+       { WERR_SECTOR_NOT_FOUND, "The drive cannot find the sector requested." },
+       { WERR_OUT_OF_PAPER, "The printer is out of paper." },
+       { WERR_WRITE_FAULT, "The system cannot write to the specified device." },
+       { WERR_READ_FAULT, "The system cannot read from the specified device." },
+       { WERR_GEN_FAILURE, "A device attached to the system is not functioning." },
+       { WERR_SHARING_VIOLATION, "The process cannot access the file because it is being used by another process." },
+       { WERR_LOCK_VIOLATION, "The process cannot access the file because another process has locked a portion of the file." },
+       { WERR_WRONG_DISK, "The wrong disk is in the drive. Insert %2 (Volume Serial Number: %3) into drive %1." },
+       { WERR_SHARING_BUFFER_EXCEEDED, "Too many files opened for sharing." },
+       { WERR_HANDLE_EOF, "Reached the end of the file." },
+       { WERR_HANDLE_DISK_FULL, "The disk is full." },
+       { WERR_NOT_SUPPORTED, "The request is not supported." },
+       { WERR_REM_NOT_LIST, "Windows cannot find the network path. Verify that the network path is correct and the destination computer is not busy or turned off. If Windows still cannot find the network path, contact your network administrator." },
+       { WERR_DUP_NAME, "You were not connected because a duplicate name exists on the network. Go to System in Control Panel to change the computer name, and then try again." },
+       { WERR_BAD_NETPATH, "The network path was not found." },
+       { WERR_NETWORK_BUSY, "The network is busy." },
+       { WERR_DEV_NOT_EXIST, "The specified network resource or device is no longer available." },
+       { WERR_TOO_MANY_CMDS, "The network BIOS command limit has been reached." },
+       { WERR_ADAP_HDW_ERR, "A network adapter hardware error occurred." },
+       { WERR_BAD_NET_RESP, "The specified server cannot perform the requested operation." },
+       { WERR_UNEXP_NET_ERR, "An unexpected network error occurred." },
+       { WERR_BAD_REM_ADAP, "The remote adapter is not compatible." },
+       { WERR_PRINTQ_FULL, "The print queue is full." },
+       { WERR_NO_SPOOL_SPACE, "Space to store the file waiting to be printed is not available on the server." },
+       { WERR_PRINT_CANCELLED, "Your file waiting to be printed was deleted." },
+       { WERR_NETNAME_DELETED, "The specified network name is no longer available." },
+       { WERR_NETWORK_ACCESS_DENIED, "Network access is denied." },
+       { WERR_BAD_DEV_TYPE, "The network resource type is not correct." },
+       { WERR_BAD_NET_NAME, "The network name cannot be found." },
+       { WERR_TOO_MANY_NAMES, "The name limit for the local computer network adapter card was exceeded." },
+       { WERR_TOO_MANY_SESS, "The network BIOS session limit was exceeded." },
+       { WERR_SHARING_PAUSED, "The remote server has been paused or is in the process of being started." },
+       { WERR_REQ_NOT_ACCEP, "No more connections can be made to this remote computer at this time because the computer has accepted the maximum number of connections." },
+       { WERR_REDIR_PAUSED, "The specified printer or disk device has been paused." },
+       { WERR_FILE_EXISTS, "The file exists." },
+       { WERR_CANNOT_MAKE, "The directory or file cannot be created." },
+       { WERR_FAIL_I24, "Fail on INT 24." },
+       { WERR_OUT_OF_STRUCTURES, "Storage to process this request is not available." },
+       { WERR_ALREADY_ASSIGNED, "The local device name is already in use." },
+       { WERR_INVALID_PASSWORD, "The specified network password is not correct." },
+       { WERR_INVALID_PARAMETER, "The parameter is incorrect." },
+       { WERR_NET_WRITE_FAULT, "A write fault occurred on the network." },
+       { WERR_NO_PROC_SLOTS, "The system cannot start another process at this time." },
+       { WERR_TOO_MANY_SEMAPHORES, "Cannot create another system semaphore." },
+       { WERR_EXCL_SEM_ALREADY_OWNED, "The exclusive semaphore is owned by another process." },
+       { WERR_SEM_IS_SET, "The semaphore is set and cannot be closed." },
+       { WERR_TOO_MANY_SEM_REQUESTS, "The semaphore cannot be set again." },
+       { WERR_INVALID_AT_INTERRUPT_TIME, "Cannot request exclusive semaphores at interrupt time." },
+       { WERR_SEM_OWNER_DIED, "The previous ownership of this semaphore has ended." },
+       { WERR_SEM_USER_LIMIT, "Insert the disk for drive %1." },
+       { WERR_DISK_CHANGE, "The program stopped because an alternate disk was not inserted." },
+       { WERR_DRIVE_LOCKED, "The disk is in use or locked by another process." },
+       { WERR_BROKEN_PIPE, "The pipe has been ended." },
+       { WERR_OPEN_FAILED, "The system cannot open the device or file specified." },
+       { WERR_BUFFER_OVERFLOW, "The file name is too long." },
+       { WERR_DISK_FULL, "There is not enough space on the disk." },
+       { WERR_NO_MORE_SEARCH_HANDLES, "No more internal file identifiers are available." },
+       { WERR_INVALID_TARGET_HANDLE, "The target internal file identifier is incorrect." },
+       { WERR_INVALID_CATEGORY, "The Input Output Control (IOCTL) call made by the application program is not correct." },
+       { WERR_INVALID_VERIFY_SWITCH, "The verify-on-write switch parameter value is not correct." },
+       { WERR_BAD_DRIVER_LEVEL, "The system does not support the command requested." },
+       { WERR_CALL_NOT_IMPLEMENTED, "This function is not supported on this system." },
+       { WERR_SEM_TIMEOUT, "The semaphore time-out period has expired." },
+       { WERR_INSUFFICIENT_BUFFER, "The data area passed to a system call is too small." },
+       { WERR_INVALID_NAME, "The file name, directory name, or volume label syntax is incorrect." },
+       { WERR_INVALID_LEVEL, "The system call level is not correct." },
+       { WERR_NO_VOLUME_LABEL, "The disk has no volume label." },
+       { WERR_MOD_NOT_FOUND, "The specified module could not be found." },
+       { WERR_PROC_NOT_FOUND, "The specified procedure could not be found." },
+       { WERR_WAIT_NO_CHILDREN, "There are no child processes to wait for." },
+       { WERR_CHILD_NOT_COMPLETE, "The %1 application cannot be run in Win32 mode." },
+       { WERR_DIRECT_ACCESS_HANDLE, "Attempt to use a file handle to an open disk partition for an operation other than raw disk I/O." },
+       { WERR_NEGATIVE_SEEK, "An attempt was made to move the file pointer before the beginning of the file." },
+       { WERR_SEEK_ON_DEVICE, "The file pointer cannot be set on the specified device or file." },
+       { WERR_NOT_SUBSTED, "The system tried to delete the substitution of a drive that is not substituted." },
+       { WERR_JOIN_TO_JOIN, "The system tried to join a drive to a directory on a joined drive." },
+       { WERR_SUBST_TO_SUBST, "The system tried to substitute a drive to a directory on a substituted drive." },
+       { WERR_JOIN_TO_SUBST, "The system tried to join a drive to a directory on a substituted drive." },
+       { WERR_SAME_DRIVE, "The system cannot join or substitute a drive to or for a directory on the same drive." },
+       { WERR_DIR_NOT_ROOT, "The directory is not a subdirectory of the root directory." },
+       { WERR_DIR_NOT_EMPTY, "The directory is not empty." },
+       { WERR_IS_SUBST_PATH, "The path specified is being used in a substitute." },
+       { WERR_IS_JOIN_PATH, "Not enough resources are available to process this command." },
+       { WERR_PATH_BUSY, "The path specified cannot be used at this time." },
+       { WERR_IS_SUBST_TARGET, "An attempt was made to join or substitute a drive for which a directory on the drive is the target of a previous substitute." },
+       { WERR_SYSTEM_TRACE, "System trace information was not specified in your CONFIG.SYS file, or tracing is disallowed." },
+       { WERR_INVALID_EVENT_COUNT, "The number of specified semaphore events for DosMuxSemWait is not correct." },
+       { WERR_TOO_MANY_MUXWAITERS, "DosMuxSemWait did not execute; too many semaphores are already set." },
+       { WERR_INVALID_LIST_FORMAT, "The DosMuxSemWait list is not correct." },
+       { WERR_LABEL_TOO_LONG, "The volume label you entered exceeds the label character limit of the destination file system." },
+       { WERR_TOO_MANY_TCBS, "Cannot create another thread." },
+       { WERR_SIGNAL_REFUSED, "The recipient process has refused the signal." },
+       { WERR_DISCARDED, "The segment is already discarded and cannot be locked." },
+       { WERR_NOT_LOCKED, "The segment is already unlocked." },
+       { WERR_BAD_THREADID_ADDR, "The address for the thread ID is not correct." },
+       { WERR_BAD_ARGUMENTS, "One or more arguments are not correct." },
+       { WERR_BAD_PATHNAME, "The specified path is invalid." },
+       { WERR_SIGNAL_PENDING, "A signal is already pending." },
+       { WERR_MAX_THRDS_REACHED, "No more threads can be created in the system." },
+       { WERR_LOCK_FAILED, "Unable to lock a region of a file." },
+       { WERR_BUSY, "The requested resource is in use." },
+       { WERR_CANCEL_VIOLATION, "A lock request was not outstanding for the supplied cancel region." },
+       { WERR_ATOMIC_LOCKS_NOT_SUPPORTED, "The file system does not support atomic changes to the lock type." },
+       { WERR_INVALID_SEGMENT_NUMBER, "The system detected a segment number that was not correct." },
+       { WERR_INVALID_ORDINAL, "The operating system cannot run %1." },
+       { WERR_ALREADY_EXISTS, "Cannot create a file when that file already exists." },
+       { WERR_INVALID_FLAG_NUMBER, "The flag passed is not correct." },
+       { WERR_SEM_NOT_FOUND, "The specified system semaphore name was not found." },
+       { WERR_INVALID_STARTING_CODESEG, "The operating system cannot run %1." },
+       { WERR_INVALID_STACKSEG, "The operating system cannot run %1." },
+       { WERR_INVALID_MODULETYPE, "The operating system cannot run %1." },
+       { WERR_INVALID_EXE_SIGNATURE, "Cannot run %1 in Win32 mode." },
+       { WERR_EXE_MARKED_INVALID, "The operating system cannot run %1." },
+       { WERR_BAD_EXE_FORMAT, "%1 is not a valid Win32 application." },
+       { WERR_ITERATED_DATA_EXCEEDS_64K, "The operating system cannot run %1." },
+       { WERR_INVALID_MINALLOCSIZE, "The operating system cannot run %1." },
+       { WERR_DYNLINK_FROM_INVALID_RING, "The operating system cannot run this application program." },
+       { WERR_IOPL_NOT_ENABLED, "The operating system is not presently configured to run this application." },
+       { WERR_INVALID_SEGDPL, "The operating system cannot run %1." },
+       { WERR_AUTODATASEG_EXCEEDS_64K, "The operating system cannot run this application program." },
+       { WERR_RING2SEG_MUST_BE_MOVABLE, "The code segment cannot be greater than or equal to 64 KB." },
+       { WERR_RELOC_CHAIN_XEEDS_SEGLIM, "The operating system cannot run %1." },
+       { WERR_INFLOOP_IN_RELOC_CHAIN, "The operating system cannot run %1." },
+       { WERR_ENVVAR_NOT_FOUND, "The system could not find the environment option that was entered." },
+       { WERR_NO_SIGNAL_SENT, "No process in the command subtree has a signal handler." },
+       { WERR_FILENAME_EXCED_RANGE, "The file name or extension is too long." },
+       { WERR_RING2_STACK_IN_USE, "The ring 2 stack is in use." },
+       { WERR_META_EXPANSION_TOO_LONG, "The asterisk (*) or question mark (?) global file name characters are entered incorrectly, or too many global file name characters are specified." },
+       { WERR_INVALID_SIGNAL_NUMBER, "The signal being posted is not correct." },
+       { WERR_THREAD_1_INACTIVE, "The signal handler cannot be set." },
+       { WERR_LOCKED, "The segment is locked and cannot be reallocated." },
+       { WERR_TOO_MANY_MODULES, "Too many dynamic-link modules are attached to this program or dynamic-link module." },
+       { WERR_NESTING_NOT_ALLOWED, "Cannot nest calls to LoadModule." },
+       { WERR_EXE_MACHINE_TYPE_MISMATCH, "This version of %1 is not compatible with the version of Windows you\'re running. Check your computer\'s system information to see whether you need an x86 (32-bit) or x64 (64-bit) version of the program, and then contact the software publisher." },
+       { WERR_EXE_CANNOT_MODIFY_SIGNED_BINARY, "The image file %1 is signed, unable to modify." },
+       { WERR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY, "The image file %1 is strong signed, unable to modify." },
+       { WERR_FILE_CHECKED_OUT, "This file is checked out or locked for editing by another user." },
+       { WERR_CHECKOUT_REQUIRED, "The file must be checked out before saving changes." },
+       { WERR_BAD_FILE_TYPE, "The file type being saved or retrieved has been blocked." },
+       { WERR_FILE_TOO_LARGE, "The file size exceeds the limit allowed and cannot be saved." },
+       { WERR_FORMS_AUTH_REQUIRED, "Access denied. Before opening files in this location, you must first browse to the Web site and select the option to sign in automatically." },
+       { WERR_VIRUS_INFECTED, "Operation did not complete successfully because the file contains a virus." },
+       { WERR_VIRUS_DELETED, "This file contains a virus and cannot be opened. Due to the nature of this virus, the file has been removed from this location." },
+       { WERR_PIPE_LOCAL, "The pipe is local." },
+       { WERR_BAD_PIPE, "The pipe state is invalid." },
+       { WERR_PIPE_BUSY, "All pipe instances are busy." },
+       { WERR_NO_DATA, "The pipe is being closed." },
+       { WERR_PIPE_NOT_CONNECTED, "No process is on the other end of the pipe." },
+       { WERR_MORE_DATA, "More data is available." },
+       { WERR_VC_DISCONNECTED, "The session was canceled." },
+       { WERR_INVALID_EA_NAME, "The specified extended attribute name was invalid." },
+       { WERR_EA_LIST_INCONSISTENT, "The extended attributes are inconsistent." },
+       { WERR_WAIT_TIMEOUT, "The wait operation timed out." },
+       { WERR_NO_MORE_ITEMS, "No more data is available." },
+       { WERR_CANNOT_COPY, "The copy functions cannot be used." },
+       { WERR_DIRECTORY, "The directory name is invalid." },
+       { WERR_EAS_DIDNT_FIT, "The extended attributes did not fit in the buffer." },
+       { WERR_EA_FILE_CORRUPT, "The extended attribute file on the mounted file system is corrupt." },
+       { WERR_EA_TABLE_FULL, "The extended attribute table file is full." },
+       { WERR_INVALID_EA_HANDLE, "The specified extended attribute handle is invalid." },
+       { WERR_EAS_NOT_SUPPORTED, "The mounted file system does not support extended attributes." },
+       { WERR_NOT_OWNER, "Attempt to release mutex not owned by caller." },
+       { WERR_TOO_MANY_POSTS, "Too many posts were made to a semaphore." },
+       { WERR_PARTIAL_COPY, "Only part of a ReadProcessMemory or WriteProcessMemory request was completed." },
+       { WERR_OPLOCK_NOT_GRANTED, "The oplock request is denied." },
+       { WERR_INVALID_OPLOCK_PROTOCOL, "An invalid oplock acknowledgment was received by the system." },
+       { WERR_DISK_TOO_FRAGMENTED, "The volume is too fragmented to complete this operation." },
+       { WERR_DELETE_PENDING, "The file cannot be opened because it is in the process of being deleted." },
+       { WERR_MR_MID_NOT_FOUND, "The system cannot find message text for message number 0x%1 in the message file for %2." },
+       { WERR_SCOPE_NOT_FOUND, "The scope specified was not found." },
+       { WERR_FAIL_NOACTION_REBOOT, "No action was taken because a system reboot is required." },
+       { WERR_FAIL_SHUTDOWN, "The shutdown operation failed." },
+       { WERR_FAIL_RESTART, "The restart operation failed." },
+       { WERR_MAX_SESSIONS_REACHED, "The maximum number of sessions has been reached." },
+       { WERR_THREAD_MODE_ALREADY_BACKGROUND, "The thread is already in background processing mode." },
+       { WERR_THREAD_MODE_NOT_BACKGROUND, "The thread is not in background processing mode." },
+       { WERR_PROCESS_MODE_ALREADY_BACKGROUND, "The process is already in background processing mode." },
+       { WERR_PROCESS_MODE_NOT_BACKGROUND, "The process is not in background processing mode." },
+       { WERR_INVALID_ADDRESS, "Attempt to access invalid address." },
+       { WERR_USER_PROFILE_LOAD, "User profile cannot be loaded." },
+       { WERR_ARITHMETIC_OVERFLOW, "Arithmetic result exceeded 32 bits." },
+       { WERR_PIPE_CONNECTED, "There is a process on the other end of the pipe." },
+       { WERR_PIPE_LISTENING, "Waiting for a process to open the other end of the pipe." },
+       { WERR_VERIFIER_STOP, "Application verifier has found an error in the current process." },
+       { WERR_ABIOS_ERROR, "An error occurred in the ABIOS subsystem." },
+       { WERR_WX86_WARNING, "A warning occurred in the WX86 subsystem." },
+       { WERR_WX86_ERROR, "An error occurred in the WX86 subsystem." },
+       { WERR_TIMER_NOT_CANCELED, "An attempt was made to cancel or set a timer that has an associated asynchronous procedure call (APC) and the subject thread is not the thread that originally set the timer with an associated APC routine." },
+       { WERR_UNWIND, "Unwind exception code." },
+       { WERR_BAD_STACK, "An invalid or unaligned stack was encountered during an unwind operation." },
+       { WERR_INVALID_UNWIND_TARGET, "An invalid unwind target was encountered during an unwind operation." },
+       { WERR_INVALID_PORT_ATTRIBUTES, "Invalid object attributes specified to NtCreatePort or invalid port attributes specified to NtConnectPort." },
+       { WERR_PORT_MESSAGE_TOO_LONG, "Length of message passed to NtRequestPort or NtRequestWaitReplyPort was longer than the maximum message allowed by the port." },
+       { WERR_INVALID_QUOTA_LOWER, "An attempt was made to lower a quota limit below the current usage." },
+       { WERR_DEVICE_ALREADY_ATTACHED, "An attempt was made to attach to a device that was already attached to another device." },
+       { WERR_INSTRUCTION_MISALIGNMENT, "An attempt was made to execute an instruction at an unaligned address, and the host system does not support unaligned instruction references." },
+       { WERR_PROFILING_NOT_STARTED, "Profiling not started." },
+       { WERR_PROFILING_NOT_STOPPED, "Profiling not stopped." },
+       { WERR_COULD_NOT_INTERPRET, "The passed ACL did not contain the minimum required information." },
+       { WERR_PROFILING_AT_LIMIT, "The number of active profiling objects is at the maximum and no more may be started." },
+       { WERR_CANT_WAIT, "Used to indicate that an operation cannot continue without blocking for I/O." },
+       { WERR_CANT_TERMINATE_SELF, "Indicates that a thread attempted to terminate itself by default (called NtTerminateThread with NULL) and it was the last thread in the current process." },
+       { WERR_UNEXPECTED_MM_CREATE_ERR, "If an MM error is returned that is not defined in the standard FsRtl filter, it is converted to one of the following errors that is guaranteed to be in the filter. In this case, information is lost; however, the filter correctly handles the exception." },
+       { WERR_UNEXPECTED_MM_MAP_ERROR, "If an MM error is returned that is not defined in the standard FsRtl filter, it is converted to one of the following errors that is guaranteed to be in the filter. In this case, information is lost; however, the filter correctly handles the exception." },
+       { WERR_UNEXPECTED_MM_EXTEND_ERR, "If an MM error is returned that is not defined in the standard FsRtl filter, it is converted to one of the following errors that is guaranteed to be in the filter. In this case, information is lost; however, the filter correctly handles the exception." },
+       { WERR_BAD_FUNCTION_TABLE, "A malformed function table was encountered during an unwind operation." },
+       { WERR_NO_GUID_TRANSLATION, "Indicates that an attempt was made to assign protection to a file system file or directory and one of the SIDs in the security descriptor could not be translated into a GUID that could be stored by the file system. This causes the protection attempt to fail, which may cause a file creation attempt to fail." },
+       { WERR_INVALID_LDT_SIZE, "Indicates that an attempt was made to grow a local domain table (LDT) by setting its size, or that the size was not an even number of selectors." },
+       { WERR_INVALID_LDT_OFFSET, "Indicates that the starting value for the LDT information was not an integral multiple of the selector size." },
+       { WERR_INVALID_LDT_DESCRIPTOR, "Indicates that the user supplied an invalid descriptor when trying to set up LDT descriptors." },
+       { WERR_TOO_MANY_THREADS, "Indicates a process has too many threads to perform the requested action. For example, assignment of a primary token may only be performed when a process has zero or one threads." },
+       { WERR_THREAD_NOT_IN_PROCESS, "An attempt was made to operate on a thread within a specific process, but the thread specified is not in the process specified." },
+       { WERR_PAGEFILE_QUOTA_EXCEEDED, "Page file quota was exceeded." },
+       { WERR_LOGON_SERVER_CONFLICT, "The Netlogon service cannot start because another Netlogon service running in the domain conflicts with the specified role." },
+       { WERR_SYNCHRONIZATION_REQUIRED, "The Security Accounts Manager (SAM) database on a Windows Server is significantly out of synchronization with the copy on the domain controller. A complete synchronization is required." },
+       { WERR_NET_OPEN_FAILED, "The NtCreateFile API failed. This error should never be returned to an application, it is a place holder for the Windows LAN Manager Redirector to use in its internal error mapping routines." },
+       { WERR_IO_PRIVILEGE_FAILED, "{Privilege Failed} The I/O permissions for the process could not be changed." },
+       { WERR_CONTROL_C_EXIT, "{Application Exit by CTRL+C} The application terminated as a result of a CTRL+C." },
+       { WERR_MISSING_SYSTEMFILE, "{Missing System File} The required system file %hs is bad or missing." },
+       { WERR_UNHANDLED_EXCEPTION, "{Application Error} The exception %s (0x%08lx) occurred in the application at location 0x%08lx." },
+       { WERR_APP_INIT_FAILURE, "{Application Error} The application failed to initialize properly (0x%lx). Click OK to terminate the application." },
+       { WERR_PAGEFILE_CREATE_FAILED, "{Unable to Create Paging File} The creation of the paging file %hs failed (%lx). The requested size was %ld." },
+       { WERR_INVALID_IMAGE_HASH, "The hash for the image cannot be found in the system catalogs. The image is likely corrupt or the victim of tampering." },
+       { WERR_NO_PAGEFILE, "{No Paging File Specified} No paging file was specified in the system configuration." },
+       { WERR_ILLEGAL_FLOAT_CONTEXT, "{EXCEPTION} A real-mode application issued a floating-point instruction, and floating-point hardware is not present." },
+       { WERR_NO_EVENT_PAIR, "An event pair synchronization operation was performed using the thread-specific client/server event pair object, but no event pair object was associated with the thread." },
+       { WERR_DOMAIN_CTRLR_CONFIG_ERROR, "A Windows Server has an incorrect configuration." },
+       { WERR_ILLEGAL_CHARACTER, "An illegal character was encountered. For a multibyte character set, this includes a lead byte without a succeeding trail byte. For the Unicode character set, this includes the characters 0xFFFF and 0xFFFE." },
+       { WERR_UNDEFINED_CHARACTER, "The Unicode character is not defined in the Unicode character set installed on the system." },
+       { WERR_FLOPPY_VOLUME, "The paging file cannot be created on a floppy disk." },
+       { WERR_BIOS_FAILED_TO_CONNECT_INTERRUPT, "The system bios failed to connect a system interrupt to the device or bus for which the device is connected." },
+       { WERR_BACKUP_CONTROLLER, "This operation is only allowed for the primary domain controller (PDC) of the domain." },
+       { WERR_MUTANT_LIMIT_EXCEEDED, "An attempt was made to acquire a mutant such that its maximum count would have been exceeded." },
+       { WERR_FS_DRIVER_REQUIRED, "A volume has been accessed for which a file system driver is required that has not yet been loaded." },
+       { WERR_CANNOT_LOAD_REGISTRY_FILE, "{Registry File Failure} The registry cannot load the hive (file): %hs or its log or alternate. It is corrupt, absent, or not writable." },
+       { WERR_DEBUG_ATTACH_FAILED, "{Unexpected Failure in DebugActiveProcess} An unexpected failure occurred while processing a DebugActiveProcess API request. You may choose OK to terminate the process, or Cancel to ignore the error." },
+       { WERR_SYSTEM_PROCESS_TERMINATED, "{Fatal System Error} The %hs system process terminated unexpectedly with a status of 0x%08x (0x%08x 0x%08x). The system has been shut down." },
+       { WERR_DATA_NOT_ACCEPTED, "{Data Not Accepted} The transport driver interface (TDI) client could not handle the data received during an indication." },
+       { WERR_VDM_HARD_ERROR, "The NT Virtual DOS Machine (NTVDM) encountered a hard error." },
+       { WERR_DRIVER_CANCEL_TIMEOUT, "{Cancel Timeout} The driver %hs failed to complete a canceled I/O request in the allotted time." },
+       { WERR_REPLY_MESSAGE_MISMATCH, "{Reply Message Mismatch} An attempt was made to reply to a local procedure call (LPC) message, but the thread specified by the client ID in the message was not waiting on that message." },
+       { WERR_LOST_WRITEBEHIND_DATA, "{Delayed Write Failed} Windows was unable to save all the data for the file %hs. The data has been lost. This error may be caused by a failure of your computer hardware or network connection. Try to save this file elsewhere." },
+       { WERR_CLIENT_SERVER_PARAMETERS_INVALID, "The parameters passed to the server in the client/server shared memory window were invalid. Too much data may have been put in the shared memory window." },
+       { WERR_NOT_TINY_STREAM, "The stream is not a tiny stream." },
+       { WERR_STACK_OVERFLOW_READ, "The request must be handled by the stack overflow code." },
+       { WERR_CONVERT_TO_LARGE, "Internal OFS status codes indicating how an allocation operation is handled. Either it is retried after the containing onode is moved or the extent stream is converted to a large stream." },
+       { WERR_FOUND_OUT_OF_SCOPE, "The attempt to find the object found an object matching by ID on the volume but it is out of the scope of the handle used for the operation." },
+       { WERR_ALLOCATE_BUCKET, "The bucket array must be grown. Retry transaction after doing so." },
+       { WERR_MARSHALL_OVERFLOW, "The user/kernel marshaling buffer has overflowed." },
+       { WERR_INVALID_VARIANT, "The supplied variant structure contains invalid data." },
+       { WERR_BAD_COMPRESSION_BUFFER, "The specified buffer contains ill-formed data." },
+       { WERR_AUDIT_FAILED, "{Audit Failed} An attempt to generate a security audit failed." },
+       { WERR_TIMER_RESOLUTION_NOT_SET, "The timer resolution was not previously set by the current process." },
+       { WERR_INSUFFICIENT_LOGON_INFO, "There is insufficient account information to log you on." },
+       { WERR_BAD_DLL_ENTRYPOINT, "{Invalid DLL Entrypoint} The dynamic link library %hs is not written correctly. The stack pointer has been left in an inconsistent state. The entry point should be declared as WINAPI or STDCALL. Select YES to fail the DLL load. Select NO to continue execution. Selecting NO may cause the application to operate incorrectly." },
+       { WERR_BAD_SERVICE_ENTRYPOINT, "{Invalid Service Callback Entrypoint} The %hs service is not written correctly. The stack pointer has been left in an inconsistent state. The callback entry point should be declared as WINAPI or STDCALL. Selecting OK will cause the service to continue operation. However, the service process may operate incorrectly." },
+       { WERR_IP_ADDRESS_CONFLICT1, "There is an IP address conflict with another system on the network." },
+       { WERR_IP_ADDRESS_CONFLICT2, "There is an IP address conflict with another system on the network." },
+       { WERR_REGISTRY_QUOTA_LIMIT, "{Low On Registry Space} The system has reached the maximum size allowed for the system part of the registry. Additional storage requests will be ignored." },
+       { WERR_NO_CALLBACK_ACTIVE, "A callback return system service cannot be executed when no callback is active." },
+       { WERR_PWD_TOO_SHORT, "The password provided is too short to meet the policy of your user account. Choose a longer password." },
+       { WERR_PWD_TOO_RECENT, "The policy of your user account does not allow you to change passwords too frequently. This is done to prevent users from changing back to a familiar, but potentially discovered, password. If you feel your password has been compromised, contact your administrator immediately to have a new one assigned." },
+       { WERR_PWD_HISTORY_CONFLICT, "You have attempted to change your password to one that you have used in the past. The policy of your user account does not allow this. Select a password that you have not previously used." },
+       { WERR_UNSUPPORTED_COMPRESSION, "The specified compression format is unsupported." },
+       { WERR_INVALID_HW_PROFILE, "The specified hardware profile configuration is invalid." },
+       { WERR_INVALID_PLUGPLAY_DEVICE_PATH, "The specified Plug and Play registry device path is invalid." },
+       { WERR_QUOTA_LIST_INCONSISTENT, "The specified quota list is internally inconsistent with its descriptor." },
+       { WERR_EVALUATION_EXPIRATION, "{Windows Evaluation Notification} The evaluation period for this installation of Windows has expired. This system will shut down in 1 hour. To restore access to this installation of Windows, upgrade this installation using a licensed distribution of this product." },
+       { WERR_ILLEGAL_DLL_RELOCATION, "{Illegal System DLL Relocation} The system DLL %hs was relocated in memory. The application will not run properly. The relocation occurred because the DLL %hs occupied an address range reserved for Windows system DLLs. The vendor supplying the DLL should be contacted for a new DLL." },
+       { WERR_DLL_INIT_FAILED_LOGOFF, "{DLL Initialization Failed} The application failed to initialize because the window station is shutting down." },
+       { WERR_VALIDATE_CONTINUE, "The validation process needs to continue on to the next step." },
+       { WERR_NO_MORE_MATCHES, "There are no more matches for the current index enumeration." },
+       { WERR_RANGE_LIST_CONFLICT, "The range could not be added to the range list because of a conflict." },
+       { WERR_SERVER_SID_MISMATCH, "The server process is running under a SID different than that required by the client." },
+       { WERR_CANT_ENABLE_DENY_ONLY, "A group marked use for deny only cannot be enabled." },
+       { WERR_FLOAT_MULTIPLE_FAULTS, "{EXCEPTION} Multiple floating point faults." },
+       { WERR_FLOAT_MULTIPLE_TRAPS, "{EXCEPTION} Multiple floating point traps." },
+       { WERR_NOINTERFACE, "The requested interface is not supported." },
+       { WERR_DRIVER_FAILED_SLEEP, "{System Standby Failed} The driver %hs does not support standby mode. Updating this driver may allow the system to go to standby mode." },
+       { WERR_CORRUPT_SYSTEM_FILE, "The system file %1 has become corrupt and has been replaced." },
+       { WERR_COMMITMENT_MINIMUM, "{Virtual Memory Minimum Too Low} Your system is low on virtual memory. Windows is increasing the size of your virtual memory paging file. During this process, memory requests for some applications may be denied. For more information, see Help." },
+       { WERR_PNP_RESTART_ENUMERATION, "A device was removed so enumeration must be restarted." },
+       { WERR_SYSTEM_IMAGE_BAD_SIGNATURE, "{Fatal System Error} The system image %s is not properly signed. The file has been replaced with the signed file. The system has been shut down." },
+       { WERR_PNP_REBOOT_REQUIRED, "Device will not start without a reboot." },
+       { WERR_INSUFFICIENT_POWER, "There is not enough power to complete the requested operation." },
+       { WERR_MULTIPLE_FAULT_VIOLATION, "ERROR_MULTIPLE_FAULT_VIOLATION" },
+       { WERR_SYSTEM_SHUTDOWN, "The system is in the process of shutting down." },
+       { WERR_PORT_NOT_SET, "An attempt to remove a process DebugPort was made, but a port was not already associated with the process." },
+       { WERR_DS_VERSION_CHECK_FAILURE, "This version of Windows is not compatible with the behavior version of directory forest, domain, or domain controller." },
+       { WERR_RANGE_NOT_FOUND, "The specified range could not be found in the range list." },
+       { WERR_NOT_SAFE_MODE_DRIVER, "The driver was not loaded because the system is booting into safe mode." },
+       { WERR_FAILED_DRIVER_ENTRY, "The driver was not loaded because it failed its initialization call." },
+       { WERR_DEVICE_ENUMERATION_ERROR, "The device encountered an error while applying power or reading the device configuration. This may be caused by a failure of your hardware or by a poor connection." },
+       { WERR_MOUNT_POINT_NOT_RESOLVED, "The create operation failed because the name contained at least one mount point that resolves to a volume to which the specified device object is not attached." },
+       { WERR_INVALID_DEVICE_OBJECT_PARAMETER, "The device object parameter is either not a valid device object or is not attached to the volume specified by the file name." },
+       { WERR_MCA_OCCURED, "A machine check error has occurred. Check the system event log for additional information." },
+       { WERR_DRIVER_DATABASE_ERROR, "There was an error [%2] processing the driver database." },
+       { WERR_SYSTEM_HIVE_TOO_LARGE, "The system hive size has exceeded its limit." },
+       { WERR_DRIVER_FAILED_PRIOR_UNLOAD, "The driver could not be loaded because a previous version of the driver is still in memory." },
+       { WERR_VOLSNAP_PREPARE_HIBERNATE, "{Volume Shadow Copy Service} Wait while the Volume Shadow Copy Service prepares volume %hs for hibernation." },
+       { WERR_HIBERNATION_FAILURE, "The system has failed to hibernate (the error code is %hs). Hibernation will be disabled until the system is restarted." },
+       { WERR_FILE_SYSTEM_LIMITATION, "The requested operation could not be completed due to a file system limitation." },
+       { WERR_ASSERTION_FAILURE, "An assertion failure has occurred." },
+       { WERR_ACPI_ERROR, "An error occurred in the Advanced Configuration and Power Interface (ACPI) subsystem." },
+       { WERR_WOW_ASSERTION, "WOW assertion error." },
+       { WERR_PNP_BAD_MPS_TABLE, "A device is missing in the system BIOS MultiProcessor Specification (MPS) table. This device will not be used. Contact your system vendor for system BIOS update." },
+       { WERR_PNP_TRANSLATION_FAILED, "A translator failed to translate resources." },
+       { WERR_PNP_IRQ_TRANSLATION_FAILED, "An interrupt request (IRQ) translator failed to translate resources." },
+       { WERR_PNP_INVALID_ID, "Driver %2 returned invalid ID for a child device (%3)." },
+       { WERR_WAKE_SYSTEM_DEBUGGER, "{Kernel Debugger Awakened} the system debugger was awakened by an interrupt." },
+       { WERR_HANDLES_CLOSED, "{Handles Closed} Handles to objects have been automatically closed because of the requested operation." },
+       { WERR_EXTRANEOUS_INFORMATION, "{Too Much Information} The specified ACL contained more information than was expected." },
+       { WERR_RXACT_COMMIT_NECESSARY, "This warning level status indicates that the transaction state already exists for the registry subtree, but that a transaction commit was previously aborted. The commit has NOT been completed, but it has not been rolled back either (so it may still be committed if desired)." },
+       { WERR_MEDIA_CHECK, "{Media Changed} The media may have changed." },
+       { WERR_GUID_SUBSTITUTION_MADE, "{GUID Substitution} During the translation of a GUID to a Windows SID, no administratively defined GUID prefix was found. A substitute prefix was used, which will not compromise system security. However, this may provide more restrictive access than intended." },
+       { WERR_STOPPED_ON_SYMLINK, "The create operation stopped after reaching a symbolic link." },
+       { WERR_LONGJUMP, "A long jump has been executed." },
+       { WERR_PLUGPLAY_QUERY_VETOED, "The Plug and Play query operation was not successful." },
+       { WERR_UNWIND_CONSOLIDATE, "A frame consolidation has been executed." },
+       { WERR_REGISTRY_HIVE_RECOVERED, "{Registry Hive Recovered} Registry hive (file): %hs was corrupted and it has been recovered. Some data might have been lost." },
+       { WERR_DLL_MIGHT_BE_INSECURE, "The application is attempting to run executable code from the module %hs. This may be insecure. An alternative, %hs, is available. Should the application use the secure module %hs?" },
+       { WERR_DLL_MIGHT_BE_INCOMPATIBLE, "The application is loading executable code from the module %hs. This is secure, but may be incompatible with previous releases of the operating system. An alternative, %hs, is available. Should the application use the secure module %hs?" },
+       { WERR_DBG_EXCEPTION_NOT_HANDLED, "Debugger did not handle the exception." },
+       { WERR_DBG_REPLY_LATER, "Debugger will reply later." },
+       { WERR_DBG_UNABLE_TO_PROVIDE_HANDLE, "Debugger cannot provide handle." },
+       { WERR_DBG_TERMINATE_THREAD, "Debugger terminated thread." },
+       { WERR_DBG_TERMINATE_PROCESS, "Debugger terminated process." },
+       { WERR_DBG_CONTROL_C, "Debugger got control C." },
+       { WERR_DBG_PRINTEXCEPTION_C, "Debugger printed exception on control C." },
+       { WERR_DBG_RIPEXCEPTION, "Debugger received Routing Information Protocol (RIP) exception." },
+       { WERR_DBG_CONTROL_BREAK, "Debugger received control break." },
+       { WERR_DBG_COMMAND_EXCEPTION, "Debugger command communication exception." },
+       { WERR_OBJECT_NAME_EXISTS, "{Object Exists} An attempt was made to create an object and the object name already existed." },
+       { WERR_THREAD_WAS_SUSPENDED, "{Thread Suspended} A thread termination occurred while the thread was suspended. The thread was resumed and termination proceeded." },
+       { WERR_IMAGE_NOT_AT_BASE, "{Image Relocated} An image file could not be mapped at the address specified in the image file. Local fixes must be performed on this image." },
+       { WERR_RXACT_STATE_CREATED, "This informational level status indicates that a specified registry subtree transaction state did not yet exist and had to be created." },
+       { WERR_SEGMENT_NOTIFICATION, "{Segment Load} A virtual DOS machine (VDM) is loading, unloading, or moving an MS-DOS or Win16 program segment image. An exception is raised so a debugger can load, unload, or track symbols and breakpoints within these 16-bit segments." },
+       { WERR_BAD_CURRENT_DIRECTORY, "{Invalid Current Directory} The process cannot switch to the startup current directory %hs. Select OK to set current directory to %hs, or select CANCEL to exit." },
+       { WERR_FT_READ_RECOVERY_FROM_BACKUP, "{Redundant Read} To satisfy a read request, the NT fault-tolerant file system successfully read the requested data from a redundant copy. This was done because the file system encountered a failure on a member of the fault-tolerant volume, but it was unable to reassign the failing area of the device." },
+       { WERR_FT_WRITE_RECOVERY, "{Redundant Write} To satisfy a write request, the Windows NT fault-tolerant file system successfully wrote a redundant copy of the information. This was done because the file system encountered a failure on a member of the fault-tolerant volume, but it was not able to reassign the failing area of the device." },
+       { WERR_IMAGE_MACHINE_TYPE_MISMATCH, "{Machine Type Mismatch} The image file %hs is valid, but is for a machine type other than the current machine. Select OK to continue, or CANCEL to fail the DLL load." },
+       { WERR_RECEIVE_PARTIAL, "{Partial Data Received} The network transport returned partial data to its client. The remaining data will be sent later." },
+       { WERR_RECEIVE_EXPEDITED, "{Expedited Data Received} The network transport returned data to its client that was marked as expedited by the remote system." },
+       { WERR_RECEIVE_PARTIAL_EXPEDITED, "{Partial Expedited Data Received} The network transport returned partial data to its client and this data was marked as expedited by the remote system. The remaining data will be sent later." },
+       { WERR_EVENT_DONE, "{TDI Event Done} The TDI indication has completed successfully." },
+       { WERR_EVENT_PENDING, "{TDI Event Pending} The TDI indication has entered the pending state." },
+       { WERR_CHECKING_FILE_SYSTEM, "Checking file system on %wZ." },
+       { WERR_FATAL_APP_EXIT, "{Fatal Application Exit} %hs." },
+       { WERR_PREDEFINED_HANDLE, "The specified registry key is referenced by a predefined handle." },
+       { WERR_WAS_UNLOCKED, "{Page Unlocked} The page protection of a locked page was changed to \'No Access\' and the page was unlocked from memory and from the process." },
+       { WERR_SERVICE_NOTIFICATION, "%hs" },
+       { WERR_WAS_LOCKED, "{Page Locked} One of the pages to lock was already locked." },
+       { WERR_LOG_HARD_ERROR, "Application popup: %1 : %2" },
+       { WERR_ALREADY_WIN32, "The value already corresponds with a Win 32 error code." },
+       { WERR_IMAGE_MACHINE_TYPE_MISMATCH_EXE, "{Machine Type Mismatch} The image file %hs is valid, but is for a machine type other than the current machine." },
+       { WERR_NO_YIELD_PERFORMED, "A yield execution was performed and no thread was available to run." },
+       { WERR_TIMER_RESUME_IGNORED, "The resume flag to a timer API was ignored." },
+       { WERR_ARBITRATION_UNHANDLED, "The arbiter has deferred arbitration of these resources to its parent" },
+       { WERR_CARDBUS_NOT_SUPPORTED, "The inserted CardBus device cannot be started because of a configuration error on %hs\".\"" },
+       { WERR_MP_PROCESSOR_MISMATCH, "The CPUs in this multiprocessor system are not all the same revision level. To use all processors the operating system restricts itself to the features of the least capable processor in the system. If problems occur with this system, contact the CPU manufacturer to see if this mix of processors is supported." },
+       { WERR_HIBERNATED, "The system was put into hibernation." },
+       { WERR_RESUME_HIBERNATION, "The system was resumed from hibernation." },
+       { WERR_FIRMWARE_UPDATED, "Windows has detected that the system firmware (BIOS) was updated (previous firmware date = %2, current firmware date %3)." },
+       { WERR_DRIVERS_LEAKING_LOCKED_PAGES, "A device driver is leaking locked I/O pages, causing system degradation. The system has automatically enabled a tracking code to try and catch the culprit." },
+       { WERR_WAKE_SYSTEM, "The system has awoken." },
+       { WERR_WAIT_1, "ERROR_WAIT_1" },
+       { WERR_WAIT_2, "ERROR_WAIT_2" },
+       { WERR_WAIT_3, "ERROR_WAIT_3" },
+       { WERR_WAIT_63, "ERROR_WAIT_63" },
+       { WERR_ABANDONED_WAIT_0, "ERROR_ABANDONED_WAIT_0" },
+       { WERR_ABANDONED_WAIT_63, "ERROR_ABANDONED_WAIT_63" },
+       { WERR_USER_APC, "ERROR_USER_APC" },
+       { WERR_KERNEL_APC, "ERROR_KERNEL_APC" },
+       { WERR_ALERTED, "ERROR_ALERTED" },
+       { WERR_ELEVATION_REQUIRED, "The requested operation requires elevation." },
+       { WERR_REPARSE, "A reparse should be performed by the object manager because the name of the file resulted in a symbolic link." },
+       { WERR_OPLOCK_BREAK_IN_PROGRESS, "An open/create operation completed while an oplock break is underway." },
+       { WERR_VOLUME_MOUNTED, "A new volume has been mounted by a file system." },
+       { WERR_RXACT_COMMITTED, "This success level status indicates that the transaction state already exists for the registry subtree, but that a transaction commit was previously aborted. The commit has now been completed." },
+       { WERR_NOTIFY_CLEANUP, "This indicates that a notify change request has been completed due to closing the handle which made the notify change request." },
+       { WERR_PRIMARY_TRANSPORT_CONNECT_FAILED, "{Connect Failure on Primary Transport} An attempt was made to connect to the remote server %hs on the primary transport, but the connection failed. The computer was able to connect on a secondary transport." },
+       { WERR_PAGE_FAULT_TRANSITION, "Page fault was a transition fault." },
+       { WERR_PAGE_FAULT_DEMAND_ZERO, "Page fault was a demand zero fault." },
+       { WERR_PAGE_FAULT_COPY_ON_WRITE, "Page fault was a demand zero fault." },
+       { WERR_PAGE_FAULT_GUARD_PAGE, "Page fault was a demand zero fault." },
+       { WERR_PAGE_FAULT_PAGING_FILE, "Page fault was satisfied by reading from a secondary storage device." },
+       { WERR_CACHE_PAGE_LOCKED, "Cached page was locked during operation." },
+       { WERR_CRASH_DUMP, "Crash dump exists in paging file." },
+       { WERR_BUFFER_ALL_ZEROS, "Specified buffer contains all zeros." },
+       { WERR_REPARSE_OBJECT, "A reparse should be performed by the object manager because the name of the file resulted in a symbolic link." },
+       { WERR_RESOURCE_REQUIREMENTS_CHANGED, "The device has succeeded a query-stop and its resource requirements have changed." },
+       { WERR_TRANSLATION_COMPLETE, "The translator has translated these resources into the global space and no further translations should be performed." },
+       { WERR_NOTHING_TO_TERMINATE, "A process being terminated has no threads to terminate." },
+       { WERR_PROCESS_NOT_IN_JOB, "The specified process is not part of a job." },
+       { WERR_PROCESS_IN_JOB, "The specified process is part of a job." },
+       { WERR_VOLSNAP_HIBERNATE_READY, "{Volume Shadow Copy Service} The system is now ready for hibernation." },
+       { WERR_FSFILTER_OP_COMPLETED_SUCCESSFULLY, "A file system or file system filter driver has successfully completed an FsFilter operation." },
+       { WERR_INTERRUPT_VECTOR_ALREADY_CONNECTED, "The specified interrupt vector was already connected." },
+       { WERR_INTERRUPT_STILL_CONNECTED, "The specified interrupt vector is still connected." },
+       { WERR_WAIT_FOR_OPLOCK, "An operation is blocked waiting for an oplock." },
+       { WERR_DBG_EXCEPTION_HANDLED, "Debugger handled exception." },
+       { WERR_DBG_CONTINUE, "Debugger continued." },
+       { WERR_CALLBACK_POP_STACK, "An exception occurred in a user mode callback and the kernel callback frame should be removed." },
+       { WERR_COMPRESSION_DISABLED, "Compression is disabled for this volume." },
+       { WERR_CANTFETCHBACKWARDS, "The data provider cannot fetch backward through a result set." },
+       { WERR_CANTSCROLLBACKWARDS, "The data provider cannot scroll backward through a result set." },
+       { WERR_ROWSNOTRELEASED, "The data provider requires that previously fetched data is released before asking for more data." },
+       { WERR_BAD_ACCESSOR_FLAGS, "The data provider was not able to interpret the flags set for a column binding in an accessor." },
+       { WERR_ERRORS_ENCOUNTERED, "One or more errors occurred while processing the request." },
+       { WERR_NOT_CAPABLE, "The implementation is not capable of performing the request." },
+       { WERR_REQUEST_OUT_OF_SEQUENCE, "The client of a component requested an operation that is not valid given the state of the component instance." },
+       { WERR_VERSION_PARSE_ERROR, "A version number could not be parsed." },
+       { WERR_BADSTARTPOSITION, "The iterator\'s start position is invalid." },
+       { WERR_MEMORY_HARDWARE, "The hardware has reported an uncorrectable memory error." },
+       { WERR_DISK_REPAIR_DISABLED, "The attempted operation required self-healing to be enabled." },
+       { WERR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE, "The Desktop heap encountered an error while allocating session memory. There is more information in the system event log." },
+       { WERR_SYSTEM_POWERSTATE_TRANSITION, "The system power state is transitioning from %2 to %3." },
+       { WERR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION, "The system power state is transitioning from %2 to %3 but could enter %4." },
+       { WERR_MCA_EXCEPTION, "A thread is getting dispatched with MCA EXCEPTION because of MCA." },
+       { WERR_ACCESS_AUDIT_BY_POLICY, "Access to %1 is monitored by policy rule %2." },
+       { WERR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY, "Access to %1 has been restricted by your administrator by policy rule %2." },
+       { WERR_ABANDON_HIBERFILE, "A valid hibernation file has been invalidated and should be abandoned." },
+       { WERR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED, "{Delayed Write Failed} Windows was unable to save all the data for the file %hs; the data has been lost. This error may be caused by network connectivity issues. Try to save this file elsewhere." },
+       { WERR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR, "{Delayed Write Failed} Windows was unable to save all the data for the file %hs; the data has been lost. This error was returned by the server on which the file exists. Try to save this file elsewhere." },
+       { WERR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR, "{Delayed Write Failed} Windows was unable to save all the data for the file %hs; the data has been lost. This error may be caused if the device has been removed or the media is write-protected." },
+       { WERR_EA_ACCESS_DENIED, "Access to the extended attribute was denied." },
+       { WERR_OPERATION_ABORTED, "The I/O operation has been aborted because of either a thread exit or an application request." },
+       { WERR_IO_INCOMPLETE, "Overlapped I/O event is not in a signaled state." },
+       { WERR_IO_PENDING, "Overlapped I/O operation is in progress." },
+       { WERR_NOACCESS, "Invalid access to memory location." },
+       { WERR_SWAPERROR, "Error performing in-page operation." },
+       { WERR_STACK_OVERFLOW, "Recursion too deep; the stack overflowed." },
+       { WERR_INVALID_MESSAGE, "The window cannot act on the sent message." },
+       { WERR_CAN_NOT_COMPLETE, "Cannot complete this function." },
+       { WERR_INVALID_FLAGS, "Invalid flags." },
+       { WERR_UNRECOGNIZED_VOLUME, "The volume does not contain a recognized file system. Be sure that all required file system drivers are loaded and that the volume is not corrupted." },
+       { WERR_FILE_INVALID, "The volume for a file has been externally altered so that the opened file is no longer valid." },
+       { WERR_FULLSCREEN_MODE, "The requested operation cannot be performed in full-screen mode." },
+       { WERR_NO_TOKEN, "An attempt was made to reference a token that does not exist." },
+       { WERR_BADDB, "The configuration registry database is corrupt." },
+       { WERR_BADKEY, "The configuration registry key is invalid." },
+       { WERR_CANTOPEN, "The configuration registry key could not be opened." },
+       { WERR_CANTREAD, "The configuration registry key could not be read." },
+       { WERR_CANTWRITE, "The configuration registry key could not be written." },
+       { WERR_REGISTRY_RECOVERED, "One of the files in the registry database had to be recovered by use of a log or alternate copy. The recovery was successful." },
+       { WERR_REGISTRY_CORRUPT, "The registry is corrupted. The structure of one of the files containing registry data is corrupted, or the system\'s memory image of the file is corrupted, or the file could not be recovered because the alternate copy or log was absent or corrupted." },
+       { WERR_REGISTRY_IO_FAILED, "An I/O operation initiated by the registry failed and cannot be recovered. The registry could not read in, write out, or flush one of the files that contain the system\'s image of the registry." },
+       { WERR_NOT_REGISTRY_FILE, "The system attempted to load or restore a file into the registry, but the specified file is not in a registry file format." },
+       { WERR_KEY_DELETED, "Illegal operation attempted on a registry key that has been marked for deletion." },
+       { WERR_NO_LOG_SPACE, "System could not allocate the required space in a registry log." },
+       { WERR_KEY_HAS_CHILDREN, "Cannot create a symbolic link in a registry key that already has subkeys or values." },
+       { WERR_CHILD_MUST_BE_VOLATILE, "Cannot create a stable subkey under a volatile parent key." },
+       { WERR_NOTIFY_ENUM_DIR, "A notify change request is being completed and the information is not being returned in the caller\'s buffer. The caller now needs to enumerate the files to find the changes." },
+       { WERR_DEPENDENT_SERVICES_RUNNING, "A stop control has been sent to a service that other running services are dependent on." },
+       { WERR_INVALID_SERVICE_CONTROL, "The requested control is not valid for this service." },
+       { WERR_SERVICE_REQUEST_TIMEOUT, "The service did not respond to the start or control request in a timely fashion." },
+       { WERR_SERVICE_NO_THREAD, "A thread could not be created for the service." },
+       { WERR_SERVICE_DATABASE_LOCKED, "The service database is locked." },
+       { WERR_SERVICE_ALREADY_RUNNING, "An instance of the service is already running." },
+       { WERR_INVALID_SERVICE_ACCOUNT, "The account name is invalid or does not exist, or the password is invalid for the account name specified." },
+       { WERR_SERVICE_DISABLED, "The service cannot be started, either because it is disabled or because it has no enabled devices associated with it." },
+       { WERR_CIRCULAR_DEPENDENCY, "Circular service dependency was specified." },
+       { WERR_SERVICE_DOES_NOT_EXIST, "The specified service does not exist as an installed service." },
+       { WERR_SERVICE_CANNOT_ACCEPT_CTRL, "The service cannot accept control messages at this time." },
+       { WERR_SERVICE_NOT_ACTIVE, "The service has not been started." },
+       { WERR_FAILED_SERVICE_CONTROLLER_CONNECT, "The service process could not connect to the service controller." },
+       { WERR_EXCEPTION_IN_SERVICE, "An exception occurred in the service when handling the control request." },
+       { WERR_DATABASE_DOES_NOT_EXIST, "The database specified does not exist." },
+       { WERR_SERVICE_SPECIFIC_ERROR, "The service has returned a service-specific error code." },
+       { WERR_PROCESS_ABORTED, "The process terminated unexpectedly." },
+       { WERR_SERVICE_DEPENDENCY_FAIL, "The dependency service or group failed to start." },
+       { WERR_SERVICE_LOGON_FAILED, "The service did not start due to a logon failure." },
+       { WERR_SERVICE_START_HANG, "After starting, the service hung in a start-pending state." },
+       { WERR_INVALID_SERVICE_LOCK, "The specified service database lock is invalid." },
+       { WERR_SERVICE_MARKED_FOR_DELETE, "The specified service has been marked for deletion." },
+       { WERR_SERVICE_EXISTS, "The specified service already exists." },
+       { WERR_ALREADY_RUNNING_LKG, "The system is currently running with the last-known-good configuration." },
+       { WERR_SERVICE_DEPENDENCY_DELETED, "The dependency service does not exist or has been marked for deletion." },
+       { WERR_BOOT_ALREADY_ACCEPTED, "The current boot has already been accepted for use as the last-known-good control set." },
+       { WERR_SERVICE_NEVER_STARTED, "No attempts to start the service have been made since the last boot." },
+       { WERR_DUPLICATE_SERVICE_NAME, "The name is already in use as either a service name or a service display name." },
+       { WERR_DIFFERENT_SERVICE_ACCOUNT, "The account specified for this service is different from the account specified for other services running in the same process." },
+       { WERR_CANNOT_DETECT_DRIVER_FAILURE, "Failure actions can only be set for Win32 services, not for drivers." },
+       { WERR_CANNOT_DETECT_PROCESS_ABORT, "This service runs in the same process as the service control manager. Therefore, the service control manager cannot take action if this service\'s process terminates unexpectedly." },
+       { WERR_NO_RECOVERY_PROGRAM, "No recovery program has been configured for this service." },
+       { WERR_SERVICE_NOT_IN_EXE, "The executable program that this service is configured to run in does not implement the service." },
+       { WERR_NOT_SAFEBOOT_SERVICE, "This service cannot be started in Safe Mode." },
+       { WERR_END_OF_MEDIA, "The physical end of the tape has been reached." },
+       { WERR_FILEMARK_DETECTED, "A tape access reached a filemark." },
+       { WERR_BEGINNING_OF_MEDIA, "The beginning of the tape or a partition was encountered." },
+       { WERR_SETMARK_DETECTED, "A tape access reached the end of a set of files." },
+       { WERR_NO_DATA_DETECTED, "No more data is on the tape." },
+       { WERR_PARTITION_FAILURE, "Tape could not be partitioned." },
+       { WERR_INVALID_BLOCK_LENGTH, "When accessing a new tape of a multivolume partition, the current block size is incorrect." },
+       { WERR_DEVICE_NOT_PARTITIONED, "Tape partition information could not be found when loading a tape." },
+       { WERR_UNABLE_TO_LOCK_MEDIA, "Unable to lock the media eject mechanism." },
+       { WERR_UNABLE_TO_UNLOAD_MEDIA, "Unable to unload the media." },
+       { WERR_MEDIA_CHANGED, "The media in the drive may have changed." },
+       { WERR_BUS_RESET, "The I/O bus was reset." },
+       { WERR_NO_MEDIA_IN_DRIVE, "No media in drive." },
+       { WERR_NO_UNICODE_TRANSLATION, "No mapping for the Unicode character exists in the target multibyte code page." },
+       { WERR_DLL_INIT_FAILED, "A DLL initialization routine failed." },
+       { WERR_SHUTDOWN_IN_PROGRESS, "A system shutdown is in progress." },
+       { WERR_NO_SHUTDOWN_IN_PROGRESS, "Unable to abort the system shutdown because no shutdown was in progress." },
+       { WERR_IO_DEVICE, "The request could not be performed because of an I/O device error." },
+       { WERR_SERIAL_NO_DEVICE, "No serial device was successfully initialized. The serial driver will unload." },
+       { WERR_IRQ_BUSY, "Unable to open a device that was sharing an IRQ with other devices. At least one other device that uses that IRQ was already opened." },
+       { WERR_MORE_WRITES, "A serial I/O operation was completed by another write to the serial port. (The IOCTL_SERIAL_XOFF_COUNTER reached zero.)" },
+       { WERR_COUNTER_TIMEOUT, "A serial I/O operation completed because the time-out period expired. (The IOCTL_SERIAL_XOFF_COUNTER did not reach zero.)" },
+       { WERR_FLOPPY_ID_MARK_NOT_FOUND, "No ID address mark was found on the floppy disk." },
+       { WERR_FLOPPY_WRONG_CYLINDER, "Mismatch between the floppy disk sector ID field and the floppy disk controller track address." },
+       { WERR_FLOPPY_UNKNOWN_ERROR, "The floppy disk controller reported an error that is not recognized by the floppy disk driver." },
+       { WERR_FLOPPY_BAD_REGISTERS, "The floppy disk controller returned inconsistent results in its registers." },
+       { WERR_DISK_RECALIBRATE_FAILED, "While accessing the hard disk, a recalibrate operation failed, even after retries." },
+       { WERR_DISK_OPERATION_FAILED, "While accessing the hard disk, a disk operation failed even after retries." },
+       { WERR_DISK_RESET_FAILED, "While accessing the hard disk, a disk controller reset was needed, but that also failed." },
+       { WERR_EOM_OVERFLOW, "Physical end of tape encountered." },
+       { WERR_NOT_ENOUGH_SERVER_MEMORY, "Not enough server storage is available to process this command." },
+       { WERR_POSSIBLE_DEADLOCK, "A potential deadlock condition has been detected." },
+       { WERR_MAPPED_ALIGNMENT, "The base address or the file offset specified does not have the proper alignment." },
+       { WERR_SET_POWER_STATE_VETOED, "An attempt to change the system power state was vetoed by another application or driver." },
+       { WERR_SET_POWER_STATE_FAILED, "The system BIOS failed an attempt to change the system power state." },
+       { WERR_TOO_MANY_LINKS, "An attempt was made to create more links on a file than the file system supports." },
+       { WERR_OLD_WIN_VERSION, "The specified program requires a newer version of Windows." },
+       { WERR_APP_WRONG_OS, "The specified program is not a Windows or MS-DOS program." },
+       { WERR_SINGLE_INSTANCE_APP, "Cannot start more than one instance of the specified program." },
+       { WERR_RMODE_APP, "The specified program was written for an earlier version of Windows." },
+       { WERR_INVALID_DLL, "One of the library files needed to run this application is damaged." },
+       { WERR_NO_ASSOCIATION, "No application is associated with the specified file for this operation." },
+       { WERR_DDE_FAIL, "An error occurred in sending the command to the application." },
+       { WERR_DLL_NOT_FOUND, "One of the library files needed to run this application cannot be found." },
+       { WERR_NO_MORE_USER_HANDLES, "The current process has used all of its system allowance of handles for Windows manager objects." },
+       { WERR_MESSAGE_SYNC_ONLY, "The message can be used only with synchronous operations." },
+       { WERR_SOURCE_ELEMENT_EMPTY, "The indicated source element has no media." },
+       { WERR_DESTINATION_ELEMENT_FULL, "The indicated destination element already contains media." },
+       { WERR_ILLEGAL_ELEMENT_ADDRESS, "The indicated element does not exist." },
+       { WERR_MAGAZINE_NOT_PRESENT, "The indicated element is part of a magazine that is not present." },
+       { WERR_DEVICE_REINITIALIZATION_NEEDED, "The indicated device requires re-initialization due to hardware errors." },
+       { WERR_DEVICE_REQUIRES_CLEANING, "The device has indicated that cleaning is required before further operations are attempted." },
+       { WERR_DEVICE_DOOR_OPEN, "The device has indicated that its door is open." },
+       { WERR_DEVICE_NOT_CONNECTED, "The device is not connected." },
+       { WERR_NOT_FOUND, "Element not found." },
+       { WERR_NO_MATCH, "There was no match for the specified key in the index." },
+       { WERR_SET_NOT_FOUND, "The property set specified does not exist on the object." },
+       { WERR_POINT_NOT_FOUND, "The point passed to GetMouseMovePoints is not in the buffer." },
+       { WERR_NO_TRACKING_SERVICE, "The tracking (workstation) service is not running." },
+       { WERR_NO_VOLUME_ID, "The volume ID could not be found." },
+       { WERR_UNABLE_TO_REMOVE_REPLACED, "Unable to remove the file to be replaced." },
+       { WERR_UNABLE_TO_MOVE_REPLACEMENT, "Unable to move the replacement file to the file to be replaced. The file to be replaced has retained its original name." },
+       { WERR_UNABLE_TO_MOVE_REPLACEMENT_2, "Unable to move the replacement file to the file to be replaced. The file to be replaced has been renamed using the backup name." },
+       { WERR_JOURNAL_DELETE_IN_PROGRESS, "The volume change journal is being deleted." },
+       { WERR_JOURNAL_NOT_ACTIVE, "The volume change journal is not active." },
+       { WERR_POTENTIAL_FILE_FOUND, "A file was found, but it may not be the correct file." },
+       { WERR_JOURNAL_ENTRY_DELETED, "The journal entry has been deleted from the journal." },
+       { WERR_SHUTDOWN_IS_SCHEDULED, "A system shutdown has already been scheduled." },
+       { WERR_SHUTDOWN_USERS_LOGGED_ON, "The system shutdown cannot be initiated because there are other users logged on to the computer." },
+       { WERR_BAD_DEVICE, "The specified device name is invalid." },
+       { WERR_CONNECTION_UNAVAIL, "The device is not currently connected but it is a remembered connection." },
+       { WERR_DEVICE_ALREADY_REMEMBERED, "The local device name has a remembered connection to another network resource." },
+       { WERR_NO_NET_OR_BAD_PATH, "The network path was either typed incorrectly, does not exist, or the network provider is not currently available. Try retyping the path or contact your network administrator." },
+       { WERR_BAD_PROVIDER, "The specified network provider name is invalid." },
+       { WERR_CANNOT_OPEN_PROFILE, "Unable to open the network connection profile." },
+       { WERR_BAD_PROFILE, "The network connection profile is corrupted." },
+       { WERR_NOT_CONTAINER, "Cannot enumerate a noncontainer." },
+       { WERR_EXTENDED_ERROR, "An extended error has occurred." },
+       { WERR_INVALID_GROUPNAME, "The format of the specified group name is invalid." },
+       { WERR_INVALID_COMPUTERNAME, "The format of the specified computer name is invalid." },
+       { WERR_INVALID_EVENTNAME, "The format of the specified event name is invalid." },
+       { WERR_INVALID_DOMAINNAME, "The format of the specified domain name is invalid." },
+       { WERR_INVALID_SERVICENAME, "The format of the specified service name is invalid." },
+       { WERR_INVALID_NETNAME, "The format of the specified network name is invalid." },
+       { WERR_INVALID_SHARENAME, "The format of the specified share name is invalid." },
+       { WERR_INVALID_PASSWORDNAME, "The format of the specified password is invalid." },
+       { WERR_INVALID_MESSAGENAME, "The format of the specified message name is invalid." },
+       { WERR_INVALID_MESSAGEDEST, "The format of the specified message destination is invalid." },
+       { WERR_SESSION_CREDENTIAL_CONFLICT, "Multiple connections to a server or shared resource by the same user, using more than one user name, are not allowed. Disconnect all previous connections to the server or shared resource and try again." },
+       { WERR_REMOTE_SESSION_LIMIT_EXCEEDED, "An attempt was made to establish a session to a network server, but there are already too many sessions established to that server." },
+       { WERR_DUP_DOMAINNAME, "The workgroup or domain name is already in use by another computer on the network." },
+       { WERR_NO_NETWORK, "The network is not present or not started." },
+       { WERR_CANCELLED, "The operation was canceled by the user." },
+       { WERR_USER_MAPPED_FILE, "The requested operation cannot be performed on a file with a user-mapped section open." },
+       { WERR_CONNECTION_REFUSED, "The remote system refused the network connection." },
+       { WERR_GRACEFUL_DISCONNECT, "The network connection was gracefully closed." },
+       { WERR_ADDRESS_ALREADY_ASSOCIATED, "The network transport endpoint already has an address associated with it." },
+       { WERR_ADDRESS_NOT_ASSOCIATED, "An address has not yet been associated with the network endpoint." },
+       { WERR_CONNECTION_INVALID, "An operation was attempted on a nonexistent network connection." },
+       { WERR_CONNECTION_ACTIVE, "An invalid operation was attempted on an active network connection." },
+       { WERR_NETWORK_UNREACHABLE, "The network location cannot be reached. For information about network troubleshooting, see Windows Help." },
+       { WERR_HOST_UNREACHABLE, "The network location cannot be reached. For information about network troubleshooting, see Windows Help." },
+       { WERR_PROTOCOL_UNREACHABLE, "The network location cannot be reached. For information about network troubleshooting, see Windows Help." },
+       { WERR_PORT_UNREACHABLE, "No service is operating at the destination network endpoint on the remote system." },
+       { WERR_REQUEST_ABORTED, "The request was aborted." },
+       { WERR_CONNECTION_ABORTED, "The network connection was aborted by the local system." },
+       { WERR_RETRY, "The operation could not be completed. A retry should be performed." },
+       { WERR_CONNECTION_COUNT_LIMIT, "A connection to the server could not be made because the limit on the number of concurrent connections for this account has been reached." },
+       { WERR_LOGIN_TIME_RESTRICTION, "Attempting to log on during an unauthorized time of day for this account." },
+       { WERR_LOGIN_WKSTA_RESTRICTION, "The account is not authorized to log on from this station." },
+       { WERR_INCORRECT_ADDRESS, "The network address could not be used for the operation requested." },
+       { WERR_ALREADY_REGISTERED, "The service is already registered." },
+       { WERR_SERVICE_NOT_FOUND, "The specified service does not exist." },
+       { WERR_NOT_AUTHENTICATED, "The operation being requested was not performed because the user has not been authenticated." },
+       { WERR_NOT_LOGGED_ON, "The operation being requested was not performed because the user has not logged on to the network. The specified service does not exist." },
+       { WERR_CONTINUE, "Continue with work in progress." },
+       { WERR_ALREADY_INITIALIZED, "An attempt was made to perform an initialization operation when initialization has already been completed." },
+       { WERR_NO_MORE_DEVICES, "No more local devices." },
+       { WERR_NO_SUCH_SITE, "The specified site does not exist." },
+       { WERR_DOMAIN_CONTROLLER_EXISTS, "A domain controller with the specified name already exists." },
+       { WERR_ONLY_IF_CONNECTED, "This operation is supported only when you are connected to the server." },
+       { WERR_OVERRIDE_NOCHANGES, "The group policy framework should call the extension even if there are no changes." },
+       { WERR_BAD_USER_PROFILE, "The specified user does not have a valid profile." },
+       { WERR_NOT_SUPPORTED_ON_SBS, "This operation is not supported on a computer running Windows Server 2003 for Small Business Server." },
+       { WERR_SERVER_SHUTDOWN_IN_PROGRESS, "The server machine is shutting down." },
+       { WERR_HOST_DOWN, "The remote system is not available. For information about network troubleshooting, see Windows Help." },
+       { WERR_NON_ACCOUNT_SID, "The security identifier provided is not from an account domain." },
+       { WERR_NON_DOMAIN_SID, "The security identifier provided does not have a domain component." },
+       { WERR_APPHELP_BLOCK, "AppHelp dialog canceled, thus preventing the application from starting." },
+       { WERR_ACCESS_DISABLED_BY_POLICY, "This program is blocked by Group Policy. For more information, contact your system administrator." },
+       { WERR_REG_NAT_CONSUMPTION, "A program attempt to use an invalid register value. Normally caused by an uninitialized register. This error is Itanium specific." },
+       { WERR_CSCSHARE_OFFLINE, "The share is currently offline or does not exist." },
+       { WERR_PKINIT_FAILURE, "The Kerberos protocol encountered an error while validating the KDC certificate during smartcard logon. There is more information in the system event log." },
+       { WERR_SMARTCARD_SUBSYSTEM_FAILURE, "The Kerberos protocol encountered an error while attempting to utilize the smartcard subsystem." },
+       { WERR_DOWNGRADE_DETECTED, "The system detected a possible attempt to compromise security. Ensure that you can contact the server that authenticated you." },
+       { WERR_MACHINE_LOCKED, "The machine is locked and cannot be shut down without the force option." },
+       { WERR_CALLBACK_SUPPLIED_INVALID_DATA, "An application-defined callback gave invalid data when called." },
+       { WERR_SYNC_FOREGROUND_REFRESH_REQUIRED, "The Group Policy framework should call the extension in the synchronous foreground policy refresh." },
+       { WERR_DRIVER_BLOCKED, "This driver has been blocked from loading." },
+       { WERR_INVALID_IMPORT_OF_NON_DLL, "A DLL referenced a module that was neither a DLL nor the process\'s executable image." },
+       { WERR_ACCESS_DISABLED_WEBBLADE, "Windows cannot open this program because it has been disabled." },
+       { WERR_ACCESS_DISABLED_WEBBLADE_TAMPER, "Windows cannot open this program because the license enforcement system has been tampered with or become corrupted." },
+       { WERR_RECOVERY_FAILURE, "A transaction recover failed." },
+       { WERR_ALREADY_FIBER, "The current thread has already been converted to a fiber." },
+       { WERR_ALREADY_THREAD, "The current thread has already been converted from a fiber." },
+       { WERR_STACK_BUFFER_OVERRUN, "The system detected an overrun of a stack-based buffer in this application. This overrun could potentially allow a malicious user to gain control of this application." },
+       { WERR_PARAMETER_QUOTA_EXCEEDED, "Data present in one of the parameters is more than the function can operate on." },
+       { WERR_DEBUGGER_INACTIVE, "An attempt to perform an operation on a debug object failed because the object is in the process of being deleted." },
+       { WERR_DELAY_LOAD_FAILED, "An attempt to delay-load a .dll or get a function address in a delay-loaded .dll failed." },
+       { WERR_VDM_DISALLOWED, "%1 is a 16-bit application. You do not have permissions to execute 16-bit applications. Check your permissions with your system administrator." },
+       { WERR_UNIDENTIFIED_ERROR, "Insufficient information exists to identify the cause of failure." },
+       { WERR_BEYOND_VDL, "The operation occurred beyond the valid data length of the file." },
+       { WERR_INCOMPATIBLE_SERVICE_SID_TYPE, "The service start failed because one or more services in the same process have an incompatible service SID type setting. A service with a restricted service SID type can only coexist in the same process with other services with a restricted SID type." },
+       { WERR_DRIVER_PROCESS_TERMINATED, "The process hosting the driver for this device has been terminated." },
+       { WERR_IMPLEMENTATION_LIMIT, "An operation attempted to exceed an implementation-defined limit." },
+       { WERR_PROCESS_IS_PROTECTED, "Either the target process, or the target thread\'s containing process, is a protected process." },
+       { WERR_SERVICE_NOTIFY_CLIENT_LAGGING, "The service notification client is lagging too far behind the current state of services in the machine." },
+       { WERR_DISK_QUOTA_EXCEEDED, "An operation failed because the storage quota was exceeded." },
+       { WERR_CONTENT_BLOCKED, "An operation failed because the content was blocked." },
+       { WERR_INCOMPATIBLE_SERVICE_PRIVILEGE, "A privilege that the service requires to function properly does not exist in the service account configuration. You may use the Services Microsoft Management Console (MMC) snap-in (Services.msc) and the Local Security Settings MMC snap-in (Secpol.msc) to view the service configuration and the account configuration." },
+       { WERR_INVALID_LABEL, "Indicates a particular SID may not be assigned as the label of an object." },
+       { WERR_NOT_ALL_ASSIGNED, "Not all privileges or groups referenced are assigned to the caller." },
+       { WERR_SOME_NOT_MAPPED, "Some mapping between account names and SIDs was not done." },
+       { WERR_NO_QUOTAS_FOR_ACCOUNT, "No system quota limits are specifically set for this account." },
+       { WERR_LOCAL_USER_SESSION_KEY, "No encryption key is available. A well-known encryption key was returned." },
+       { WERR_NULL_LM_PASSWORD, "The password is too complex to be converted to a LAN Manager password. The LAN Manager password returned is a null string." },
+       { WERR_UNKNOWN_REVISION, "The revision level is unknown." },
+       { WERR_REVISION_MISMATCH, "Indicates two revision levels are incompatible." },
+       { WERR_INVALID_OWNER, "This SID may not be assigned as the owner of this object." },
+       { WERR_INVALID_PRIMARY_GROUP, "This SID may not be assigned as the primary group of an object." },
+       { WERR_NO_IMPERSONATION_TOKEN, "An attempt has been made to operate on an impersonation token by a thread that is not currently impersonating a client." },
+       { WERR_CANT_DISABLE_MANDATORY, "The group may not be disabled." },
+       { WERR_NO_LOGON_SERVERS, "There are currently no logon servers available to service the logon request." },
+       { WERR_NO_SUCH_LOGON_SESSION, "A specified logon session does not exist. It may already have been terminated." },
+       { WERR_NO_SUCH_PRIVILEGE, "A specified privilege does not exist." },
+       { WERR_PRIVILEGE_NOT_HELD, "A required privilege is not held by the client." },
+       { WERR_INVALID_ACCOUNT_NAME, "The name provided is not a properly formed account name." },
+       { WERR_USER_EXISTS, "The specified account already exists." },
+       { WERR_NO_SUCH_USER, "The specified account does not exist." },
+       { WERR_GROUP_EXISTS, "The specified group already exists." },
+       { WERR_NO_SUCH_GROUP, "The specified group does not exist." },
+       { WERR_MEMBER_IN_GROUP, "Either the specified user account is already a member of the specified group, or the specified group cannot be deleted because it contains a member." },
+       { WERR_MEMBER_NOT_IN_GROUP, "The specified user account is not a member of the specified group account." },
+       { WERR_LAST_ADMIN, "The last remaining administration account cannot be disabled or deleted." },
+       { WERR_WRONG_PASSWORD, "Unable to update the password. The value provided as the current password is incorrect." },
+       { WERR_ILL_FORMED_PASSWORD, "Unable to update the password. The value provided for the new password contains values that are not allowed in passwords." },
+       { WERR_PASSWORD_RESTRICTION, "Unable to update the password. The value provided for the new password does not meet the length, complexity, or history requirements of the domain." },
+       { WERR_LOGON_FAILURE, "Logon failure: Unknown user name or bad password." },
+       { WERR_ACCOUNT_RESTRICTION, "Logon failure: User account restriction. Possible reasons are blank passwords not allowed, logon hour restrictions, or a policy restriction has been enforced." },
+       { WERR_INVALID_LOGON_HOURS, "Logon failure: Account logon time restriction violation." },
+       { WERR_INVALID_WORKSTATION, "Logon failure: User not allowed to log on to this computer." },
+       { WERR_PASSWORD_EXPIRED, "Logon failure: The specified account password has expired." },
+       { WERR_ACCOUNT_DISABLED, "Logon failure: Account currently disabled." },
+       { WERR_NONE_MAPPED, "No mapping between account names and SIDs was done." },
+       { WERR_TOO_MANY_LUIDS_REQUESTED, "Too many local user identifiers (LUIDs) were requested at one time." },
+       { WERR_LUIDS_EXHAUSTED, "No more LUIDs are available." },
+       { WERR_INVALID_SUB_AUTHORITY, "The sub-authority part of an SID is invalid for this particular use." },
+       { WERR_INVALID_ACL, "The ACL structure is invalid." },
+       { WERR_INVALID_SID, "The SID structure is invalid." },
+       { WERR_INVALID_SECURITY_DESCR, "The security descriptor structure is invalid." },
+       { WERR_BAD_INHERITANCE_ACL, "The inherited ACL or ACE could not be built." },
+       { WERR_SERVER_DISABLED, "The server is currently disabled." },
+       { WERR_SERVER_NOT_DISABLED, "The server is currently enabled." },
+       { WERR_INVALID_ID_AUTHORITY, "The value provided was an invalid value for an identifier authority." },
+       { WERR_ALLOTTED_SPACE_EXCEEDED, "No more memory is available for security information updates." },
+       { WERR_INVALID_GROUP_ATTRIBUTES, "The specified attributes are invalid, or incompatible with the attributes for the group as a whole." },
+       { WERR_BAD_IMPERSONATION_LEVEL, "Either a required impersonation level was not provided, or the provided impersonation level is invalid." },
+       { WERR_CANT_OPEN_ANONYMOUS, "Cannot open an anonymous level security token." },
+       { WERR_BAD_VALIDATION_CLASS, "The validation information class requested was invalid." },
+       { WERR_BAD_TOKEN_TYPE, "The type of the token is inappropriate for its attempted use." },
+       { WERR_NO_SECURITY_ON_OBJECT, "Unable to perform a security operation on an object that has no associated security." },
+       { WERR_CANT_ACCESS_DOMAIN_INFO, "Configuration information could not be read from the domain controller, either because the machine is unavailable, or access has been denied." },
+       { WERR_INVALID_SERVER_STATE, "The SAM or local security authority (LSA) server was in the wrong state to perform the security operation." },
+       { WERR_INVALID_DOMAIN_STATE, "The domain was in the wrong state to perform the security operation." },
+       { WERR_INVALID_DOMAIN_ROLE, "This operation is only allowed for the PDC of the domain." },
+       { WERR_NO_SUCH_DOMAIN, "The specified domain either does not exist or could not be contacted." },
+       { WERR_DOMAIN_EXISTS, "The specified domain already exists." },
+       { WERR_DOMAIN_LIMIT_EXCEEDED, "An attempt was made to exceed the limit on the number of domains per server." },
+       { WERR_INTERNAL_DB_CORRUPTION, "Unable to complete the requested operation because of either a catastrophic media failure or a data structure corruption on the disk." },
+       { WERR_INTERNAL_ERROR, "An internal error occurred." },
+       { WERR_GENERIC_NOT_MAPPED, "Generic access types were contained in an access mask that should already be mapped to nongeneric types." },
+       { WERR_BAD_DESCRIPTOR_FORMAT, "A security descriptor is not in the right format (absolute or self-relative)." },
+       { WERR_NOT_LOGON_PROCESS, "The requested action is restricted for use by logon processes only. The calling process has not registered as a logon process." },
+       { WERR_LOGON_SESSION_EXISTS, "Cannot start a new logon session with an ID that is already in use." },
+       { WERR_NO_SUCH_PACKAGE, "A specified authentication package is unknown." },
+       { WERR_BAD_LOGON_SESSION_STATE, "The logon session is not in a state that is consistent with the requested operation." },
+       { WERR_LOGON_SESSION_COLLISION, "The logon session ID is already in use." },
+       { WERR_INVALID_LOGON_TYPE, "A logon request contained an invalid logon type value." },
+       { WERR_CANNOT_IMPERSONATE, "Unable to impersonate using a named pipe until data has been read from that pipe." },
+       { WERR_RXACT_INVALID_STATE, "The transaction state of a registry subtree is incompatible with the requested operation." },
+       { WERR_RXACT_COMMIT_FAILURE, "An internal security database corruption has been encountered." },
+       { WERR_SPECIAL_ACCOUNT, "Cannot perform this operation on built-in accounts." },
+       { WERR_SPECIAL_GROUP, "Cannot perform this operation on this built-in special group." },
+       { WERR_SPECIAL_USER, "Cannot perform this operation on this built-in special user." },
+       { WERR_MEMBERS_PRIMARY_GROUP, "The user cannot be removed from a group because the group is currently the user\'s primary group." },
+       { WERR_TOKEN_ALREADY_IN_USE, "The token is already in use as a primary token." },
+       { WERR_NO_SUCH_ALIAS, "The specified local group does not exist." },
+       { WERR_MEMBER_NOT_IN_ALIAS, "The specified account name is not a member of the group." },
+       { WERR_MEMBER_IN_ALIAS, "The specified account name is already a member of the group." },
+       { WERR_ALIAS_EXISTS, "The specified local group already exists." },
+       { WERR_LOGON_NOT_GRANTED, "Logon failure: The user has not been granted the requested logon type at this computer." },
+       { WERR_TOO_MANY_SECRETS, "The maximum number of secrets that may be stored in a single system has been exceeded." },
+       { WERR_SECRET_TOO_LONG, "The length of a secret exceeds the maximum length allowed." },
+       { WERR_INTERNAL_DB_ERROR, "The local security authority database contains an internal inconsistency." },
+       { WERR_TOO_MANY_CONTEXT_IDS, "During a logon attempt, the user\'s security context accumulated too many SIDs." },
+       { WERR_LOGON_TYPE_NOT_GRANTED, "Logon failure: The user has not been granted the requested logon type at this computer." },
+       { WERR_NT_CROSS_ENCRYPTION_REQUIRED, "A cross-encrypted password is necessary to change a user password." },
+       { WERR_NO_SUCH_MEMBER, "A member could not be added to or removed from the local group because the member does not exist." },
+       { WERR_INVALID_MEMBER, "A new member could not be added to a local group because the member has the wrong account type." },
+       { WERR_TOO_MANY_SIDS, "Too many SIDs have been specified." },
+       { WERR_LM_CROSS_ENCRYPTION_REQUIRED, "A cross-encrypted password is necessary to change this user password." },
+       { WERR_NO_INHERITANCE, "Indicates an ACL contains no inheritable components." },
+       { WERR_FILE_CORRUPT, "The file or directory is corrupted and unreadable." },
+       { WERR_DISK_CORRUPT, "The disk structure is corrupted and unreadable." },
+       { WERR_NO_USER_SESSION_KEY, "There is no user session key for the specified logon session." },
+       { WERR_LICENSE_QUOTA_EXCEEDED, "The service being accessed is licensed for a particular number of connections. No more connections can be made to the service at this time because the service has accepted the maximum number of connections." },
+       { WERR_WRONG_TARGET_NAME, "Logon failure: The target account name is incorrect." },
+       { WERR_MUTUAL_AUTH_FAILED, "Mutual authentication failed. The server\'s password is out of date at the domain controller." },
+       { WERR_TIME_SKEW, "There is a time and/or date difference between the client and server." },
+       { WERR_CURRENT_DOMAIN_NOT_ALLOWED, "This operation cannot be performed on the current domain." },
+       { WERR_INVALID_WINDOW_HANDLE, "Invalid window handle." },
+       { WERR_INVALID_MENU_HANDLE, "Invalid menu handle." },
+       { WERR_INVALID_CURSOR_HANDLE, "Invalid cursor handle." },
+       { WERR_INVALID_ACCEL_HANDLE, "Invalid accelerator table handle." },
+       { WERR_INVALID_HOOK_HANDLE, "Invalid hook handle." },
+       { WERR_INVALID_DWP_HANDLE, "Invalid handle to a multiple-window position structure." },
+       { WERR_TLW_WITH_WSCHILD, "Cannot create a top-level child window." },
+       { WERR_CANNOT_FIND_WND_CLASS, "Cannot find window class." },
+       { WERR_WINDOW_OF_OTHER_THREAD, "Invalid window; it belongs to other thread." },
+       { WERR_HOTKEY_ALREADY_REGISTERED, "Hot key is already registered." },
+       { WERR_CLASS_ALREADY_EXISTS, "Class already exists." },
+       { WERR_CLASS_DOES_NOT_EXIST, "Class does not exist." },
+       { WERR_CLASS_HAS_WINDOWS, "Class still has open windows." },
+       { WERR_INVALID_INDEX, "Invalid index." },
+       { WERR_INVALID_ICON_HANDLE, "Invalid icon handle." },
+       { WERR_PRIVATE_DIALOG_INDEX, "Using private DIALOG window words." },
+       { WERR_LISTBOX_ID_NOT_FOUND, "The list box identifier was not found." },
+       { WERR_NO_WILDCARD_CHARACTERS, "No wildcards were found." },
+       { WERR_CLIPBOARD_NOT_OPEN, "Thread does not have a clipboard open." },
+       { WERR_HOTKEY_NOT_REGISTERED, "Hot key is not registered." },
+       { WERR_WINDOW_NOT_DIALOG, "The window is not a valid dialog window." },
+       { WERR_CONTROL_ID_NOT_FOUND, "Control ID not found." },
+       { WERR_INVALID_COMBOBOX_MESSAGE, "Invalid message for a combo box because it does not have an edit control." },
+       { WERR_WINDOW_NOT_COMBOBOX, "The window is not a combo box." },
+       { WERR_INVALID_EDIT_HEIGHT, "Height must be less than 256." },
+       { WERR_DC_NOT_FOUND, "Invalid device context (DC) handle." },
+       { WERR_INVALID_HOOK_FILTER, "Invalid hook procedure type." },
+       { WERR_INVALID_FILTER_PROC, "Invalid hook procedure." },
+       { WERR_HOOK_NEEDS_HMOD, "Cannot set nonlocal hook without a module handle." },
+       { WERR_GLOBAL_ONLY_HOOK, "This hook procedure can only be set globally." },
+       { WERR_JOURNAL_HOOK_SET, "The journal hook procedure is already installed." },
+       { WERR_HOOK_NOT_INSTALLED, "The hook procedure is not installed." },
+       { WERR_INVALID_LB_MESSAGE, "Invalid message for single-selection list box." },
+       { WERR_SETCOUNT_ON_BAD_LB, "LB_SETCOUNT sent to non-lazy list box." },
+       { WERR_LB_WITHOUT_TABSTOPS, "This list box does not support tab stops." },
+       { WERR_DESTROY_OBJECT_OF_OTHER_THREAD, "Cannot destroy object created by another thread." },
+       { WERR_CHILD_WINDOW_MENU, "Child windows cannot have menus." },
+       { WERR_NO_SYSTEM_MENU, "The window does not have a system menu." },
+       { WERR_INVALID_MSGBOX_STYLE, "Invalid message box style." },
+       { WERR_INVALID_SPI_VALUE, "Invalid system-wide (SPI_*) parameter." },
+       { WERR_SCREEN_ALREADY_LOCKED, "Screen already locked." },
+       { WERR_HWNDS_HAVE_DIFF_PARENT, "All handles to windows in a multiple-window position structure must have the same parent." },
+       { WERR_NOT_CHILD_WINDOW, "The window is not a child window." },
+       { WERR_INVALID_GW_COMMAND, "Invalid GW_* command." },
+       { WERR_INVALID_THREAD_ID, "Invalid thread identifier." },
+       { WERR_NON_MDICHILD_WINDOW, "Cannot process a message from a window that is not a multiple document interface (MDI) window." },
+       { WERR_POPUP_ALREADY_ACTIVE, "Pop-up menu already active." },
+       { WERR_NO_SCROLLBARS, "The window does not have scroll bars." },
+       { WERR_INVALID_SCROLLBAR_RANGE, "Scroll bar range cannot be greater than MAXLONG." },
+       { WERR_INVALID_SHOWWIN_COMMAND, "Cannot show or remove the window in the way specified." },
+       { WERR_NO_SYSTEM_RESOURCES, "Insufficient system resources exist to complete the requested service." },
+       { WERR_NONPAGED_SYSTEM_RESOURCES, "Insufficient system resources exist to complete the requested service." },
+       { WERR_PAGED_SYSTEM_RESOURCES, "Insufficient system resources exist to complete the requested service." },
+       { WERR_WORKING_SET_QUOTA, "Insufficient quota to complete the requested service." },
+       { WERR_PAGEFILE_QUOTA, "Insufficient quota to complete the requested service." },
+       { WERR_COMMITMENT_LIMIT, "The paging file is too small for this operation to complete." },
+       { WERR_MENU_ITEM_NOT_FOUND, "A menu item was not found." },
+       { WERR_INVALID_KEYBOARD_HANDLE, "Invalid keyboard layout handle." },
+       { WERR_HOOK_TYPE_NOT_ALLOWED, "Hook type not allowed." },
+       { WERR_REQUIRES_INTERACTIVE_WINDOWSTATION, "This operation requires an interactive window station." },
+       { WERR_TIMEOUT, "This operation returned because the time-out period expired." },
+       { WERR_INVALID_MONITOR_HANDLE, "Invalid monitor handle." },
+       { WERR_INCORRECT_SIZE, "Incorrect size argument." },
+       { WERR_SYMLINK_CLASS_DISABLED, "The symbolic link cannot be followed because its type is disabled." },
+       { WERR_SYMLINK_NOT_SUPPORTED, "This application does not support the current operation on symbolic links." },
+       { WERR_EVENTLOG_FILE_CORRUPT, "The event log file is corrupted." },
+       { WERR_EVENTLOG_CANT_START, "No event log file could be opened, so the event logging service did not start." },
+       { WERR_LOG_FILE_FULL, "The event log file is full." },
+       { WERR_EVENTLOG_FILE_CHANGED, "The event log file has changed between read operations." },
+       { WERR_INVALID_TASK_NAME, "The specified task name is invalid." },
+       { WERR_INVALID_TASK_INDEX, "The specified task index is invalid." },
+       { WERR_THREAD_ALREADY_IN_TASK, "The specified thread is already joining a task." },
+       { WERR_INSTALL_SERVICE_FAILURE, "The Windows Installer service could not be accessed. This can occur if the Windows Installer is not correctly installed. Contact your support personnel for assistance." },
+       { WERR_INSTALL_USEREXIT, "User canceled installation." },
+       { WERR_INSTALL_FAILURE, "Fatal error during installation." },
+       { WERR_INSTALL_SUSPEND, "Installation suspended, incomplete." },
+       { WERR_UNKNOWN_PRODUCT, "This action is valid only for products that are currently installed." },
+       { WERR_UNKNOWN_FEATURE, "Feature ID not registered." },
+       { WERR_UNKNOWN_COMPONENT, "Component ID not registered." },
+       { WERR_UNKNOWN_PROPERTY, "Unknown property." },
+       { WERR_INVALID_HANDLE_STATE, "Handle is in an invalid state." },
+       { WERR_BAD_CONFIGURATION, "The configuration data for this product is corrupt. Contact your support personnel." },
+       { WERR_INDEX_ABSENT, "Component qualifier not present." },
+       { WERR_INSTALL_SOURCE_ABSENT, "The installation source for this product is not available. Verify that the source exists and that you can access it." },
+       { WERR_INSTALL_PACKAGE_VERSION, "This installation package cannot be installed by the Windows Installer service. You must install a Windows service pack that contains a newer version of the Windows Installer service." },
+       { WERR_PRODUCT_UNINSTALLED, "Product is uninstalled." },
+       { WERR_BAD_QUERY_SYNTAX, "SQL query syntax invalid or unsupported." },
+       { WERR_INVALID_FIELD, "Record field does not exist." },
+       { WERR_DEVICE_REMOVED, "The device has been removed." },
+       { WERR_INSTALL_ALREADY_RUNNING, "Another installation is already in progress. Complete that installation before proceeding with this install." },
+       { WERR_INSTALL_PACKAGE_OPEN_FAILED, "This installation package could not be opened. Verify that the package exists and that you can access it, or contact the application vendor to verify that this is a valid Windows Installer package." },
+       { WERR_INSTALL_PACKAGE_INVALID, "This installation package could not be opened. Contact the application vendor to verify that this is a valid Windows Installer package." },
+       { WERR_INSTALL_UI_FAILURE, "There was an error starting the Windows Installer service user interface. Contact your support personnel." },
+       { WERR_INSTALL_LOG_FAILURE, "Error opening installation log file. Verify that the specified log file location exists and that you can write to it." },
+       { WERR_INSTALL_LANGUAGE_UNSUPPORTED, "The language of this installation package is not supported by your system." },
+       { WERR_INSTALL_TRANSFORM_FAILURE, "Error applying transforms. Verify that the specified transform paths are valid." },
+       { WERR_INSTALL_PACKAGE_REJECTED, "This installation is forbidden by system policy. Contact your system administrator." },
+       { WERR_FUNCTION_NOT_CALLED, "Function could not be executed." },
+       { WERR_FUNCTION_FAILED, "Function failed during execution." },
+       { WERR_INVALID_TABLE, "Invalid or unknown table specified." },
+       { WERR_DATATYPE_MISMATCH, "Data supplied is of wrong type." },
+       { WERR_UNSUPPORTED_TYPE, "Data of this type is not supported." },
+       { WERR_CREATE_FAILED, "The Windows Installer service failed to start. Contact your support personnel." },
+       { WERR_INSTALL_TEMP_UNWRITABLE, "The Temp folder is on a drive that is full or is inaccessible. Free up space on the drive or verify that you have write permission on the Temp folder." },
+       { WERR_INSTALL_PLATFORM_UNSUPPORTED, "This installation package is not supported by this processor type. Contact your product vendor." },
+       { WERR_INSTALL_NOTUSED, "Component not used on this computer." },
+       { WERR_PATCH_PACKAGE_OPEN_FAILED, "This update package could not be opened. Verify that the update package exists and that you can access it, or contact the application vendor to verify that this is a valid Windows Installer update package." },
+       { WERR_PATCH_PACKAGE_INVALID, "This update package could not be opened. Contact the application vendor to verify that this is a valid Windows Installer update package." },
+       { WERR_PATCH_PACKAGE_UNSUPPORTED, "This update package cannot be processed by the Windows Installer service. You must install a Windows service pack that contains a newer version of the Windows Installer service." },
+       { WERR_PRODUCT_VERSION, "Another version of this product is already installed. Installation of this version cannot continue. To configure or remove the existing version of this product, use Add/Remove Programs in Control Panel." },
+       { WERR_INVALID_COMMAND_LINE, "Invalid command-line argument. Consult the Windows Installer SDK for detailed command line help." },
+       { WERR_INSTALL_REMOTE_DISALLOWED, "Only administrators have permission to add, remove, or configure server software during a Terminal Services remote session. If you want to install or configure software on the server, contact your network administrator." },
+       { WERR_SUCCESS_REBOOT_INITIATED, "The requested operation completed successfully. The system will be restarted so the changes can take effect." },
+       { WERR_PATCH_TARGET_NOT_FOUND, "The upgrade cannot be installed by the Windows Installer service because the program to be upgraded may be missing, or the upgrade may update a different version of the program. Verify that the program to be upgraded exists on your computer and that you have the correct upgrade." },
+       { WERR_PATCH_PACKAGE_REJECTED, "The update package is not permitted by a software restriction policy." },
+       { WERR_INSTALL_TRANSFORM_REJECTED, "One or more customizations are not permitted by a software restriction policy." },
+       { WERR_INSTALL_REMOTE_PROHIBITED, "The Windows Installer does not permit installation from a Remote Desktop Connection." },
+       { WERR_PATCH_REMOVAL_UNSUPPORTED, "Uninstallation of the update package is not supported." },
+       { WERR_UNKNOWN_PATCH, "The update is not applied to this product." },
+       { WERR_PATCH_NO_SEQUENCE, "No valid sequence could be found for the set of updates." },
+       { WERR_PATCH_REMOVAL_DISALLOWED, "Update removal was disallowed by policy." },
+       { WERR_INVALID_PATCH_XML, "The XML update data is invalid." },
+       { WERR_PATCH_MANAGED_ADVERTISED_PRODUCT, "Windows Installer does not permit updating of managed advertised products. At least one feature of the product must be installed before applying the update." },
+       { WERR_INSTALL_SERVICE_SAFEBOOT, "The Windows Installer service is not accessible in Safe Mode. Try again when your computer is not in Safe Mode or you can use System Restore to return your machine to a previous good state." },
+       { WERR_RPC_S_INVALID_STRING_BINDING, "The string binding is invalid." },
+       { WERR_RPC_S_WRONG_KIND_OF_BINDING, "The binding handle is not the correct type." },
+       { WERR_RPC_S_INVALID_BINDING, "The binding handle is invalid." },
+       { WERR_RPC_S_PROTSEQ_NOT_SUPPORTED, "The RPC protocol sequence is not supported." },
+       { WERR_RPC_S_INVALID_RPC_PROTSEQ, "The RPC protocol sequence is invalid." },
+       { WERR_RPC_S_INVALID_STRING_UUID, "The string UUID is invalid." },
+       { WERR_RPC_S_INVALID_ENDPOINT_FORMAT, "The endpoint format is invalid." },
+       { WERR_RPC_S_INVALID_NET_ADDR, "The network address is invalid." },
+       { WERR_RPC_S_NO_ENDPOINT_FOUND, "No endpoint was found." },
+       { WERR_RPC_S_INVALID_TIMEOUT, "The time-out value is invalid." },
+       { WERR_RPC_S_OBJECT_NOT_FOUND, "The object UUID) was not found." },
+       { WERR_RPC_S_ALREADY_REGISTERED, "The object UUID) has already been registered." },
+       { WERR_RPC_S_TYPE_ALREADY_REGISTERED, "The type UUID has already been registered." },
+       { WERR_RPC_S_ALREADY_LISTENING, "The RPC server is already listening." },
+       { WERR_RPC_S_NO_PROTSEQS_REGISTERED, "No protocol sequences have been registered." },
+       { WERR_RPC_S_NOT_LISTENING, "The RPC server is not listening." },
+       { WERR_RPC_S_UNKNOWN_MGR_TYPE, "The manager type is unknown." },
+       { WERR_RPC_S_UNKNOWN_IF, "The interface is unknown." },
+       { WERR_RPC_S_NO_BINDINGS, "There are no bindings." },
+       { WERR_RPC_S_NO_PROTSEQS, "There are no protocol sequences." },
+       { WERR_RPC_S_CANT_CREATE_ENDPOINT, "The endpoint cannot be created." },
+       { WERR_RPC_S_OUT_OF_RESOURCES, "Not enough resources are available to complete this operation." },
+       { WERR_RPC_S_SERVER_UNAVAILABLE, "The RPC server is unavailable." },
+       { WERR_RPC_S_SERVER_TOO_BUSY, "The RPC server is too busy to complete this operation." },
+       { WERR_RPC_S_INVALID_NETWORK_OPTIONS, "The network options are invalid." },
+       { WERR_RPC_S_NO_CALL_ACTIVE, "There are no RPCs active on this thread." },
+       { WERR_RPC_S_CALL_FAILED, "The RPC failed." },
+       { WERR_RPC_S_CALL_FAILED_DNE, "The RPC failed and did not execute." },
+       { WERR_RPC_S_PROTOCOL_ERROR, "An RPC protocol error occurred." },
+       { WERR_RPC_S_PROXY_ACCESS_DENIED, "Access to the HTTP proxy is denied." },
+       { WERR_RPC_S_UNSUPPORTED_TRANS_SYN, "The transfer syntax is not supported by the RPC server." },
+       { WERR_RPC_S_UNSUPPORTED_TYPE, "The UUID type is not supported." },
+       { WERR_RPC_S_INVALID_TAG, "The tag is invalid." },
+       { WERR_RPC_S_INVALID_BOUND, "The array bounds are invalid." },
+       { WERR_RPC_S_NO_ENTRY_NAME, "The binding does not contain an entry name." },
+       { WERR_RPC_S_INVALID_NAME_SYNTAX, "The name syntax is invalid." },
+       { WERR_RPC_S_UNSUPPORTED_NAME_SYNTAX, "The name syntax is not supported." },
+       { WERR_RPC_S_UUID_NO_ADDRESS, "No network address is available to use to construct a UUID." },
+       { WERR_RPC_S_DUPLICATE_ENDPOINT, "The endpoint is a duplicate." },
+       { WERR_RPC_S_UNKNOWN_AUTHN_TYPE, "The authentication type is unknown." },
+       { WERR_RPC_S_MAX_CALLS_TOO_SMALL, "The maximum number of calls is too small." },
+       { WERR_RPC_S_STRING_TOO_LONG, "The string is too long." },
+       { WERR_RPC_S_PROTSEQ_NOT_FOUND, "The RPC protocol sequence was not found." },
+       { WERR_RPC_S_PROCNUM_OUT_OF_RANGE, "The procedure number is out of range." },
+       { WERR_RPC_S_BINDING_HAS_NO_AUTH, "The binding does not contain any authentication information." },
+       { WERR_RPC_S_UNKNOWN_AUTHN_SERVICE, "The authentication service is unknown." },
+       { WERR_RPC_S_UNKNOWN_AUTHN_LEVEL, "The authentication level is unknown." },
+       { WERR_RPC_S_INVALID_AUTH_IDENTITY, "The security context is invalid." },
+       { WERR_RPC_S_UNKNOWN_AUTHZ_SERVICE, "The authorization service is unknown." },
+       { WERR_EPT_S_INVALID_ENTRY, "The entry is invalid." },
+       { WERR_EPT_S_CANT_PERFORM_OP, "The server endpoint cannot perform the operation." },
+       { WERR_EPT_S_NOT_REGISTERED, "There are no more endpoints available from the endpoint mapper." },
+       { WERR_RPC_S_NOTHING_TO_EXPORT, "No interfaces have been exported." },
+       { WERR_RPC_S_INCOMPLETE_NAME, "The entry name is incomplete." },
+       { WERR_RPC_S_INVALID_VERS_OPTION, "The version option is invalid." },
+       { WERR_RPC_S_NO_MORE_MEMBERS, "There are no more members." },
+       { WERR_RPC_S_NOT_ALL_OBJS_UNEXPORTED, "There is nothing to unexport." },
+       { WERR_RPC_S_INTERFACE_NOT_FOUND, "The interface was not found." },
+       { WERR_RPC_S_ENTRY_ALREADY_EXISTS, "The entry already exists." },
+       { WERR_RPC_S_ENTRY_NOT_FOUND, "The entry is not found." },
+       { WERR_RPC_S_NAME_SERVICE_UNAVAILABLE, "The name service is unavailable." },
+       { WERR_RPC_S_INVALID_NAF_ID, "The network address family is invalid." },
+       { WERR_RPC_S_CANNOT_SUPPORT, "The requested operation is not supported." },
+       { WERR_RPC_S_NO_CONTEXT_AVAILABLE, "No security context is available to allow impersonation." },
+       { WERR_RPC_S_INTERNAL_ERROR, "An internal error occurred in an RPC." },
+       { WERR_RPC_S_ZERO_DIVIDE, "The RPC server attempted an integer division by zero." },
+       { WERR_RPC_S_ADDRESS_ERROR, "An addressing error occurred in the RPC server." },
+       { WERR_RPC_S_FP_DIV_ZERO, "A floating-point operation at the RPC server caused a division by zero." },
+       { WERR_RPC_S_FP_UNDERFLOW, "A floating-point underflow occurred at the RPC server." },
+       { WERR_RPC_S_FP_OVERFLOW, "A floating-point overflow occurred at the RPC server." },
+       { WERR_RPC_X_NO_MORE_ENTRIES, "The list of RPC servers available for the binding of auto handles has been exhausted." },
+       { WERR_RPC_X_SS_CHAR_TRANS_OPEN_FAIL, "Unable to open the character translation table file." },
+       { WERR_RPC_X_SS_CHAR_TRANS_SHORT_FILE, "The file containing the character translation table has fewer than 512 bytes." },
+       { WERR_RPC_X_SS_IN_NULL_CONTEXT, "A null context handle was passed from the client to the host during an RPC." },
+       { WERR_RPC_X_SS_CONTEXT_DAMAGED, "The context handle changed during an RPC." },
+       { WERR_RPC_X_SS_HANDLES_MISMATCH, "The binding handles passed to an RPC do not match." },
+       { WERR_RPC_X_SS_CANNOT_GET_CALL_HANDLE, "The stub is unable to get the RPC handle." },
+       { WERR_RPC_X_NULL_REF_POINTER, "A null reference pointer was passed to the stub." },
+       { WERR_RPC_X_ENUM_VALUE_OUT_OF_RANGE, "The enumeration value is out of range." },
+       { WERR_RPC_X_BYTE_COUNT_TOO_SMALL, "The byte count is too small." },
+       { WERR_RPC_X_BAD_STUB_DATA, "The stub received bad data." },
+       { WERR_INVALID_USER_BUFFER, "The supplied user buffer is not valid for the requested operation." },
+       { WERR_UNRECOGNIZED_MEDIA, "The disk media is not recognized. It may not be formatted." },
+       { WERR_NO_TRUST_LSA_SECRET, "The workstation does not have a trust secret." },
+       { WERR_NO_TRUST_SAM_ACCOUNT, "The security database on the server does not have a computer account for this workstation trust relationship." },
+       { WERR_TRUSTED_DOMAIN_FAILURE, "The trust relationship between the primary domain and the trusted domain failed." },
+       { WERR_TRUSTED_RELATIONSHIP_FAILURE, "The trust relationship between this workstation and the primary domain failed." },
+       { WERR_TRUST_FAILURE, "The network logon failed." },
+       { WERR_RPC_S_CALL_IN_PROGRESS, "An RPC is already in progress for this thread." },
+       { WERR_NETLOGON_NOT_STARTED, "An attempt was made to log on, but the network logon service was not started." },
+       { WERR_ACCOUNT_EXPIRED, "The user\'s account has expired." },
+       { WERR_REDIRECTOR_HAS_OPEN_HANDLES, "The redirector is in use and cannot be unloaded." },
+       { WERR_PRINTER_DRIVER_ALREADY_INSTALLED, "The specified printer driver is already installed." },
+       { WERR_UNKNOWN_PORT, "The specified port is unknown." },
+       { WERR_UNKNOWN_PRINTER_DRIVER, "The printer driver is unknown." },
+       { WERR_UNKNOWN_PRINTPROCESSOR, "The print processor is unknown." },
+       { WERR_INVALID_SEPARATOR_FILE, "The specified separator file is invalid." },
+       { WERR_INVALID_PRIORITY, "The specified priority is invalid." },
+       { WERR_INVALID_PRINTER_NAME, "The printer name is invalid." },
+       { WERR_PRINTER_ALREADY_EXISTS, "The printer already exists." },
+       { WERR_INVALID_PRINTER_COMMAND, "The printer command is invalid." },
+       { WERR_INVALID_DATATYPE, "The specified data type is invalid." },
+       { WERR_INVALID_ENVIRONMENT, "The environment specified is invalid." },
+       { WERR_RPC_S_NO_MORE_BINDINGS, "There are no more bindings." },
+       { WERR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, "The account used is an interdomain trust account. Use your global user account or local user account to access this server." },
+       { WERR_NOLOGON_WORKSTATION_TRUST_ACCOUNT, "The account used is a computer account. Use your global user account or local user account to access this server." },
+       { WERR_NOLOGON_SERVER_TRUST_ACCOUNT, "The account used is a server trust account. Use your global user account or local user account to access this server." },
+       { WERR_DOMAIN_TRUST_INCONSISTENT, "The name or SID of the domain specified is inconsistent with the trust information for that domain." },
+       { WERR_SERVER_HAS_OPEN_HANDLES, "The server is in use and cannot be unloaded." },
+       { WERR_RESOURCE_DATA_NOT_FOUND, "The specified image file did not contain a resource section." },
+       { WERR_RESOURCE_TYPE_NOT_FOUND, "The specified resource type cannot be found in the image file." },
+       { WERR_RESOURCE_NAME_NOT_FOUND, "The specified resource name cannot be found in the image file." },
+       { WERR_RESOURCE_LANG_NOT_FOUND, "The specified resource language ID cannot be found in the image file." },
+       { WERR_NOT_ENOUGH_QUOTA, "Not enough quota is available to process this command." },
+       { WERR_RPC_S_NO_INTERFACES, "No interfaces have been registered." },
+       { WERR_RPC_S_CALL_CANCELLED, "The RPC was canceled." },
+       { WERR_RPC_S_BINDING_INCOMPLETE, "The binding handle does not contain all the required information." },
+       { WERR_RPC_S_COMM_FAILURE, "A communications failure occurred during an RPC." },
+       { WERR_RPC_S_UNSUPPORTED_AUTHN_LEVEL, "The requested authentication level is not supported." },
+       { WERR_RPC_S_NO_PRINC_NAME, "No principal name is registered." },
+       { WERR_RPC_S_NOT_RPC_ERROR, "The error specified is not a valid Windows RPC error code." },
+       { WERR_RPC_S_UUID_LOCAL_ONLY, "A UUID that is valid only on this computer has been allocated." },
+       { WERR_RPC_S_SEC_PKG_ERROR, "A security package-specific error occurred." },
+       { WERR_RPC_S_NOT_CANCELLED, "The thread is not canceled." },
+       { WERR_RPC_X_INVALID_ES_ACTION, "Invalid operation on the encoding/decoding handle." },
+       { WERR_RPC_X_WRONG_ES_VERSION, "Incompatible version of the serializing package." },
+       { WERR_RPC_X_WRONG_STUB_VERSION, "Incompatible version of the RPC stub." },
+       { WERR_RPC_X_INVALID_PIPE_OBJECT, "The RPC pipe object is invalid or corrupted." },
+       { WERR_RPC_X_WRONG_PIPE_ORDER, "An invalid operation was attempted on an RPC pipe object." },
+       { WERR_RPC_X_WRONG_PIPE_VERSION, "Unsupported RPC pipe version." },
+       { WERR_RPC_S_GROUP_MEMBER_NOT_FOUND, "The group member was not found." },
+       { WERR_EPT_S_CANT_CREATE, "The endpoint mapper database entry could not be created." },
+       { WERR_RPC_S_INVALID_OBJECT, "The object UUID is the nil UUID." },
+       { WERR_INVALID_TIME, "The specified time is invalid." },
+       { WERR_INVALID_FORM_NAME, "The specified form name is invalid." },
+       { WERR_INVALID_FORM_SIZE, "The specified form size is invalid." },
+       { WERR_ALREADY_WAITING, "The specified printer handle is already being waited on." },
+       { WERR_PRINTER_DELETED, "The specified printer has been deleted." },
+       { WERR_INVALID_PRINTER_STATE, "The state of the printer is invalid." },
+       { WERR_PASSWORD_MUST_CHANGE, "The user\'s password must be changed before logging on the first time." },
+       { WERR_DOMAIN_CONTROLLER_NOT_FOUND, "Could not find the domain controller for this domain." },
+       { WERR_ACCOUNT_LOCKED_OUT, "The referenced account is currently locked out and may not be logged on to." },
+       { WERR_OR_INVALID_OXID, "The object exporter specified was not found." },
+       { WERR_OR_INVALID_OID, "The object specified was not found." },
+       { WERR_OR_INVALID_SET, "The object set specified was not found." },
+       { WERR_RPC_S_SEND_INCOMPLETE, "Some data remains to be sent in the request buffer." },
+       { WERR_RPC_S_INVALID_ASYNC_HANDLE, "Invalid asynchronous RPC handle." },
+       { WERR_RPC_S_INVALID_ASYNC_CALL, "Invalid asynchronous RPC call handle for this operation." },
+       { WERR_RPC_X_PIPE_CLOSED, "The RPC pipe object has already been closed." },
+       { WERR_RPC_X_PIPE_DISCIPLINE_ERROR, "The RPC call completed before all pipes were processed." },
+       { WERR_RPC_X_PIPE_EMPTY, "No more data is available from the RPC pipe." },
+       { WERR_NO_SITENAME, "No site name is available for this machine." },
+       { WERR_CANT_ACCESS_FILE, "The file cannot be accessed by the system." },
+       { WERR_CANT_RESOLVE_FILENAME, "The name of the file cannot be resolved by the system." },
+       { WERR_RPC_S_ENTRY_TYPE_MISMATCH, "The entry is not of the expected type." },
+       { WERR_RPC_S_NOT_ALL_OBJS_EXPORTED, "Not all object UUIDs could be exported to the specified entry." },
+       { WERR_RPC_S_INTERFACE_NOT_EXPORTED, "The interface could not be exported to the specified entry." },
+       { WERR_RPC_S_PROFILE_NOT_ADDED, "The specified profile entry could not be added." },
+       { WERR_RPC_S_PRF_ELT_NOT_ADDED, "The specified profile element could not be added." },
+       { WERR_RPC_S_PRF_ELT_NOT_REMOVED, "The specified profile element could not be removed." },
+       { WERR_RPC_S_GRP_ELT_NOT_ADDED, "The group element could not be added." },
+       { WERR_RPC_S_GRP_ELT_NOT_REMOVED, "The group element could not be removed." },
+       { WERR_KM_DRIVER_BLOCKED, "The printer driver is not compatible with a policy enabled on your computer that blocks Windows NT 4.0 drivers." },
+       { WERR_CONTEXT_EXPIRED, "The context has expired and can no longer be used." },
+       { WERR_PER_USER_TRUST_QUOTA_EXCEEDED, "The current user\'s delegated trust creation quota has been exceeded." },
+       { WERR_ALL_USER_TRUST_QUOTA_EXCEEDED, "The total delegated trust creation quota has been exceeded." },
+       { WERR_USER_DELETE_TRUST_QUOTA_EXCEEDED, "The current user\'s delegated trust deletion quota has been exceeded." },
+       { WERR_AUTHENTICATION_FIREWALL_FAILED, "Logon failure: The machine you are logging on to is protected by an authentication firewall. The specified account is not allowed to authenticate to the machine." },
+       { WERR_REMOTE_PRINT_CONNECTIONS_BLOCKED, "Remote connections to the Print Spooler are blocked by a policy set on your machine." },
+       { WERR_INVALID_PIXEL_FORMAT, "The pixel format is invalid." },
+       { WERR_BAD_DRIVER, "The specified driver is invalid." },
+       { WERR_INVALID_WINDOW_STYLE, "The window style or class attribute is invalid for this operation." },
+       { WERR_METAFILE_NOT_SUPPORTED, "The requested metafile operation is not supported." },
+       { WERR_TRANSFORM_NOT_SUPPORTED, "The requested transformation operation is not supported." },
+       { WERR_CLIPPING_NOT_SUPPORTED, "The requested clipping operation is not supported." },
+       { WERR_INVALID_CMM, "The specified color management module is invalid." },
+       { WERR_INVALID_PROFILE, "The specified color profile is invalid." },
+       { WERR_TAG_NOT_FOUND, "The specified tag was not found." },
+       { WERR_TAG_NOT_PRESENT, "A required tag is not present." },
+       { WERR_DUPLICATE_TAG, "The specified tag is already present." },
+       { WERR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE, "The specified color profile is not associated with any device." },
+       { WERR_PROFILE_NOT_FOUND, "The specified color profile was not found." },
+       { WERR_INVALID_COLORSPACE, "The specified color space is invalid." },
+       { WERR_ICM_NOT_ENABLED, "Image Color Management is not enabled." },
+       { WERR_DELETING_ICM_XFORM, "There was an error while deleting the color transform." },
+       { WERR_INVALID_TRANSFORM, "The specified color transform is invalid." },
+       { WERR_COLORSPACE_MISMATCH, "The specified transform does not match the bitmap\'s color space." },
+       { WERR_INVALID_COLORINDEX, "The specified named color index is not present in the profile." },
+       { WERR_PROFILE_DOES_NOT_MATCH_DEVICE, "The specified profile is intended for a device of a different type than the specified device." },
+       { WERR_NERR_NETNOTSTARTED, "The workstation driver is not installed." },
+       { WERR_NERR_UNKNOWNSERVER, "The server could not be located." },
+       { WERR_NERR_SHAREMEM, "An internal error occurred. The network cannot access a shared memory segment." },
+       { WERR_NERR_NONETWORKRESOURCE, "A network resource shortage occurred." },
+       { WERR_NERR_REMOTEONLY, "This operation is not supported on workstations." },
+       { WERR_NERR_DEVNOTREDIRECTED, "The device is not connected." },
+       { WERR_CONNECTED_OTHER_PASSWORD, "The network connection was made successfully, but the user had to be prompted for a password other than the one originally specified." },
+       { WERR_CONNECTED_OTHER_PASSWORD_DEFAULT, "The network connection was made successfully using default credentials." },
+       { WERR_NERR_SERVERNOTSTARTED, "The Server service is not started." },
+       { WERR_NERR_ITEMNOTFOUND, "The queue is empty." },
+       { WERR_NERR_UNKNOWNDEVDIR, "The device or directory does not exist." },
+       { WERR_NERR_REDIRECTEDPATH, "The operation is invalid on a redirected resource." },
+       { WERR_NERR_DUPLICATESHARE, "The name has already been shared." },
+       { WERR_NERR_NOROOM, "The server is currently out of the requested resource." },
+       { WERR_NERR_TOOMANYITEMS, "Requested addition of items exceeds the maximum allowed." },
+       { WERR_NERR_INVALIDMAXUSERS, "The Peer service supports only two simultaneous users." },
+       { WERR_NERR_BUFTOOSMALL, "The API return buffer is too small." },
+       { WERR_NERR_REMOTEERR, "A remote API error occurred." },
+       { WERR_NERR_LANMANINIERROR, "An error occurred when opening or reading the configuration file." },
+       { WERR_NERR_NETWORKERROR, "A general network error occurred." },
+       { WERR_NERR_WKSTAINCONSISTENTSTATE, "The Workstation service is in an inconsistent state. Restart the computer before restarting the Workstation service." },
+       { WERR_NERR_WKSTANOTSTARTED, "The Workstation service has not been started." },
+       { WERR_NERR_BROWSERNOTSTARTED, "The requested information is not available." },
+       { WERR_NERR_INTERNALERROR, "An internal error occurred." },
+       { WERR_NERR_BADTRANSACTCONFIG, "The server is not configured for transactions." },
+       { WERR_NERR_INVALIDAPI, "The requested API is not supported on the remote server." },
+       { WERR_NERR_BADEVENTNAME, "The event name is invalid." },
+       { WERR_NERR_DUPNAMEREBOOT, "The computer name already exists on the network. Change it and reboot the computer." },
+       { WERR_NERR_CFGCOMPNOTFOUND, "The specified component could not be found in the configuration information." },
+       { WERR_NERR_CFGPARAMNOTFOUND, "The specified parameter could not be found in the configuration information." },
+       { WERR_NERR_LINETOOLONG, "A line in the configuration file is too long." },
+       { WERR_NERR_QNOTFOUND, "The printer does not exist." },
+       { WERR_NERR_JOBNOTFOUND, "The print job does not exist." },
+       { WERR_NERR_DESTNOTFOUND, "The printer destination cannot be found." },
+       { WERR_NERR_DESTEXISTS, "The printer destination already exists." },
+       { WERR_NERR_QEXISTS, "The print queue already exists." },
+       { WERR_NERR_QNOROOM, "No more printers can be added." },
+       { WERR_NERR_JOBNOROOM, "No more print jobs can be added." },
+       { WERR_NERR_DESTNOROOM, "No more printer destinations can be added." },
+       { WERR_NERR_DESTIDLE, "This printer destination is idle and cannot accept control operations." },
+       { WERR_NERR_DESTINVALIDOP, "This printer destination request contains an invalid control function." },
+       { WERR_NERR_PROCNORESPOND, "The print processor is not responding." },
+       { WERR_NERR_SPOOLERNOTLOADED, "The spooler is not running." },
+       { WERR_NERR_DESTINVALIDSTATE, "This operation cannot be performed on the print destination in its current state." },
+       { WERR_NERR_QINVALIDSTATE, "This operation cannot be performed on the print queue in its current state." },
+       { WERR_NERR_JOBINVALIDSTATE, "This operation cannot be performed on the print job in its current state." },
+       { WERR_NERR_SPOOLNOMEMORY, "A spooler memory allocation failure occurred." },
+       { WERR_NERR_DRIVERNOTFOUND, "The device driver does not exist." },
+       { WERR_NERR_DATATYPEINVALID, "The data type is not supported by the print processor." },
+       { WERR_NERR_PROCNOTFOUND, "The print processor is not installed." },
+       { WERR_NERR_SERVICETABLELOCKED, "The service database is locked." },
+       { WERR_NERR_SERVICETABLEFULL, "The service table is full." },
+       { WERR_NERR_SERVICEINSTALLED, "The requested service has already been started." },
+       { WERR_NERR_SERVICEENTRYLOCKED, "The service does not respond to control actions." },
+       { WERR_NERR_SERVICENOTINSTALLED, "The service has not been started." },
+       { WERR_NERR_BADSERVICENAME, "The service name is invalid." },
+       { WERR_NERR_SERVICECTLTIMEOUT, "The service is not responding to the control function." },
+       { WERR_NERR_SERVICECTLBUSY, "The service control is busy." },
+       { WERR_NERR_BADSERVICEPROGNAME, "The configuration file contains an invalid service program name." },
+       { WERR_NERR_SERVICENOTCTRL, "The service could not be controlled in its present state." },
+       { WERR_NERR_SERVICEKILLPROC, "The service ended abnormally." },
+       { WERR_NERR_SERVICECTLNOTVALID, "The requested pause or stop is not valid for this service." },
+       { WERR_NERR_NOTINDISPATCHTBL, "The service control dispatcher could not find the service name in the dispatch table." },
+       { WERR_NERR_BADCONTROLRECV, "The service control dispatcher pipe read failed." },
+       { WERR_NERR_SERVICENOTSTARTING, "A thread for the new service could not be created." },
+       { WERR_NERR_ALREADYLOGGEDON, "This workstation is already logged on to the LAN." },
+       { WERR_NERR_NOTLOGGEDON, "The workstation is not logged on to the LAN." },
+       { WERR_NERR_BADUSERNAME, "The user name or group name parameter is invalid." },
+       { WERR_NERR_BADPASSWORD, "The password parameter is invalid." },
+       { WERR_NERR_UNABLETOADDNAME_W, "The logon processor did not add the message alias." },
+       { WERR_NERR_UNABLETOADDNAME_F, "The logon processor did not add the message alias." },
+       { WERR_NERR_UNABLETODELNAME_W, "@W The logoff processor did not delete the message alias." },
+       { WERR_NERR_UNABLETODELNAME_F, "The logoff processor did not delete the message alias." },
+       { WERR_NERR_LOGONSPAUSED, "Network logons are paused." },
+       { WERR_NERR_LOGONSERVERCONFLICT, "A centralized logon server conflict occurred." },
+       { WERR_NERR_LOGONNOUSERPATH, "The server is configured without a valid user path." },
+       { WERR_NERR_LOGONSCRIPTERROR, "An error occurred while loading or running the logon script." },
+       { WERR_NERR_STANDALONELOGON, "The logon server was not specified. The computer will be logged on as STANDALONE." },
+       { WERR_NERR_LOGONSERVERNOTFOUND, "The logon server could not be found." },
+       { WERR_NERR_LOGONDOMAINEXISTS, "There is already a logon domain for this computer." },
+       { WERR_NERR_NONVALIDATEDLOGON, "The logon server could not validate the logon." },
+       { WERR_NERR_ACFNOTFOUND, "The security database could not be found." },
+       { WERR_NERR_GROUPNOTFOUND, "The group name could not be found." },
+       { WERR_NERR_USERNOTFOUND, "The user name could not be found." },
+       { WERR_NERR_RESOURCENOTFOUND, "The resource name could not be found." },
+       { WERR_NERR_GROUPEXISTS, "The group already exists." },
+       { WERR_NERR_USEREXISTS, "The user account already exists." },
+       { WERR_NERR_RESOURCEEXISTS, "The resource permission list already exists." },
+       { WERR_NERR_NOTPRIMARY, "This operation is allowed only on the PDC of the domain." },
+       { WERR_NERR_ACFNOTLOADED, "The security database has not been started." },
+       { WERR_NERR_ACFNOROOM, "There are too many names in the user accounts database." },
+       { WERR_NERR_ACFFILEIOFAIL, "A disk I/O failure occurred." },
+       { WERR_NERR_ACFTOOMANYLISTS, "The limit of 64 entries per resource was exceeded." },
+       { WERR_NERR_USERLOGON, "Deleting a user with a session is not allowed." },
+       { WERR_NERR_ACFNOPARENT, "The parent directory could not be located." },
+       { WERR_NERR_CANNOTGROWSEGMENT, "Unable to add to the security database session cache segment." },
+       { WERR_NERR_SPEGROUPOP, "This operation is not allowed on this special group." },
+       { WERR_NERR_NOTINCACHE, "This user is not cached in the user accounts database session cache." },
+       { WERR_NERR_USERINGROUP, "The user already belongs to this group." },
+       { WERR_NERR_USERNOTINGROUP, "The user does not belong to this group." },
+       { WERR_NERR_ACCOUNTUNDEFINED, "This user account is undefined." },
+       { WERR_NERR_ACCOUNTEXPIRED, "This user account has expired." },
+       { WERR_NERR_INVALIDWORKSTATION, "The user is not allowed to log on from this workstation." },
+       { WERR_NERR_INVALIDLOGONHOURS, "The user is not allowed to log on at this time." },
+       { WERR_NERR_PASSWORDEXPIRED, "The password of this user has expired." },
+       { WERR_NERR_PASSWORDCANTCHANGE, "The password of this user cannot change." },
+       { WERR_NERR_PASSWORDHISTCONFLICT, "This password cannot be used now." },
+       { WERR_NERR_PASSWORDTOOSHORT, "The password does not meet the password policy requirements. Check the minimum password length, password complexity, and password history requirements." },
+       { WERR_NERR_PASSWORDTOORECENT, "The password of this user is too recent to change." },
+       { WERR_NERR_INVALIDDATABASE, "The security database is corrupted." },
+       { WERR_NERR_DATABASEUPTODATE, "No updates are necessary to this replicant network or local security database." },
+       { WERR_NERR_SYNCREQUIRED, "This replicant database is outdated; synchronization is required." },
+       { WERR_NERR_USENOTFOUND, "The network connection could not be found." },
+       { WERR_NERR_BADASGTYPE, "This asg_type is invalid." },
+       { WERR_NERR_DEVICEISSHARED, "This device is currently being shared." },
+       { WERR_NERR_NOCOMPUTERNAME, "The computer name could not be added as a message alias. The name may already exist on the network." },
+       { WERR_NERR_MSGALREADYSTARTED, "The Messenger service is already started." },
+       { WERR_NERR_MSGINITFAILED, "The Messenger service failed to start." },
+       { WERR_NERR_NAMENOTFOUND, "The message alias could not be found on the network." },
+       { WERR_NERR_ALREADYFORWARDED, "This message alias has already been forwarded." },
+       { WERR_NERR_ADDFORWARDED, "This message alias has been added but is still forwarded." },
+       { WERR_NERR_ALREADYEXISTS, "This message alias already exists locally." },
+       { WERR_NERR_TOOMANYNAMES, "The maximum number of added message aliases has been exceeded." },
+       { WERR_NERR_DELCOMPUTERNAME, "The computer name could not be deleted." },
+       { WERR_NERR_LOCALFORWARD, "Messages cannot be forwarded back to the same workstation." },
+       { WERR_NERR_GRPMSGPROCESSOR, "An error occurred in the domain message processor." },
+       { WERR_NERR_PAUSEDREMOTE, "The message was sent, but the recipient has paused the Messenger service." },
+       { WERR_NERR_BADRECEIVE, "The message was sent but not received." },
+       { WERR_NERR_NAMEINUSE, "The message alias is currently in use. Try again later." },
+       { WERR_NERR_MSGNOTSTARTED, "The Messenger service has not been started." },
+       { WERR_NERR_NOTLOCALNAME, "The name is not on the local computer." },
+       { WERR_NERR_NOFORWARDNAME, "The forwarded message alias could not be found on the network." },
+       { WERR_NERR_REMOTEFULL, "The message alias table on the remote station is full." },
+       { WERR_NERR_NAMENOTFORWARDED, "Messages for this alias are not currently being forwarded." },
+       { WERR_NERR_TRUNCATEDBROADCAST, "The broadcast message was truncated." },
+       { WERR_NERR_INVALIDDEVICE, "This is an invalid device name." },
+       { WERR_NERR_WRITEFAULT, "A write fault occurred." },
+       { WERR_NERR_DUPLICATENAME, "A duplicate message alias exists on the network." },
+       { WERR_NERR_DELETELATER, "This message alias will be deleted later." },
+       { WERR_NERR_INCOMPLETEDEL, "The message alias was not successfully deleted from all networks." },
+       { WERR_NERR_MULTIPLENETS, "This operation is not supported on computers with multiple networks." },
+       { WERR_NERR_NETNAMENOTFOUND, "This shared resource does not exist." },
+       { WERR_NERR_DEVICENOTSHARED, "This device is not shared." },
+       { WERR_NERR_CLIENTNAMENOTFOUND, "A session does not exist with that computer name." },
+       { WERR_NERR_FILEIDNOTFOUND, "There is not an open file with that identification number." },
+       { WERR_NERR_EXECFAILURE, "A failure occurred when executing a remote administration command." },
+       { WERR_NERR_TMPFILE, "A failure occurred when opening a remote temporary file." },
+       { WERR_NERR_TOOMUCHDATA, "The data returned from a remote administration command has been truncated to 64 KB." },
+       { WERR_NERR_DEVICESHARECONFLICT, "This device cannot be shared as both a spooled and a nonspooled resource." },
+       { WERR_NERR_BROWSERTABLEINCOMPLETE, "The information in the list of servers may be incorrect." },
+       { WERR_NERR_NOTLOCALDOMAIN, "The computer is not active in this domain." },
+       { WERR_NERR_ISDFSSHARE, "The share must be removed from the Distributed File System (DFS) before it can be deleted." },
+       { WERR_NERR_DEVINVALIDOPCODE, "The operation is invalid for this device." },
+       { WERR_NERR_DEVNOTFOUND, "This device cannot be shared." },
+       { WERR_NERR_DEVNOTOPEN, "This device was not open." },
+       { WERR_NERR_BADQUEUEDEVSTRING, "This device name list is invalid." },
+       { WERR_NERR_BADQUEUEPRIORITY, "The queue priority is invalid." },
+       { WERR_NERR_NOCOMMDEVS, "There are no shared communication devices." },
+       { WERR_NERR_QUEUENOTFOUND, "The queue you specified does not exist." },
+       { WERR_NERR_BADDEVSTRING, "This list of devices is invalid." },
+       { WERR_NERR_BADDEV, "The requested device is invalid." },
+       { WERR_NERR_INUSEBYSPOOLER, "This device is already in use by the spooler." },
+       { WERR_NERR_COMMDEVINUSE, "This device is already in use as a communication device." },
+       { WERR_NERR_INVALIDCOMPUTER, "This computer name is invalid." },
+       { WERR_NERR_MAXLENEXCEEDED, "The string and prefix specified are too long." },
+       { WERR_NERR_BADCOMPONENT, "This path component is invalid." },
+       { WERR_NERR_CANTTYPE, "Could not determine the type of input." },
+       { WERR_NERR_TOOMANYENTRIES, "The buffer for types is not big enough." },
+       { WERR_NERR_PROFILEFILETOOBIG, "Profile files cannot exceed 64 KB." },
+       { WERR_NERR_PROFILEOFFSET, "The start offset is out of range." },
+       { WERR_NERR_PROFILECLEANUP, "The system cannot delete current connections to network resources." },
+       { WERR_NERR_PROFILEUNKNOWNCMD, "The system was unable to parse the command line in this file." },
+       { WERR_NERR_PROFILELOADERR, "An error occurred while loading the profile file." },
+       { WERR_NERR_PROFILESAVEERR, "Errors occurred while saving the profile file. The profile was partially saved." },
+       { WERR_NERR_LOGOVERFLOW, "Log file %1 is full." },
+       { WERR_NERR_LOGFILECHANGED, "This log file has changed between reads." },
+       { WERR_NERR_LOGFILECORRUPT, "Log file %1 is corrupt." },
+       { WERR_NERR_SOURCEISDIR, "The source path cannot be a directory." },
+       { WERR_NERR_BADSOURCE, "The source path is illegal." },
+       { WERR_NERR_BADDEST, "The destination path is illegal." },
+       { WERR_NERR_DIFFERENTSERVERS, "The source and destination paths are on different servers." },
+       { WERR_NERR_RUNSRVPAUSED, "The Run server you requested is paused." },
+       { WERR_NERR_ERRCOMMRUNSRV, "An error occurred when communicating with a Run server." },
+       { WERR_NERR_ERROREXECINGGHOST, "An error occurred when starting a background process." },
+       { WERR_NERR_SHARENOTFOUND, "The shared resource you are connected to could not be found." },
+       { WERR_NERR_INVALIDLANA, "The LAN adapter number is invalid." },
+       { WERR_NERR_OPENFILES, "There are open files on the connection." },
+       { WERR_NERR_ACTIVECONNS, "Active connections still exist." },
+       { WERR_NERR_BADPASSWORDCORE, "This share name or password is invalid." },
+       { WERR_NERR_DEVINUSE, "The device is being accessed by an active process." },
+       { WERR_NERR_LOCALDRIVE, "The drive letter is in use locally." },
+       { WERR_NERR_ALERTEXISTS, "The specified client is already registered for the specified event." },
+       { WERR_NERR_TOOMANYALERTS, "The alert table is full." },
+       { WERR_NERR_NOSUCHALERT, "An invalid or nonexistent alert name was raised." },
+       { WERR_NERR_BADRECIPIENT, "The alert recipient is invalid." },
+       { WERR_NERR_ACCTLIMITEXCEEDED, "A user\'s session with this server has been deleted" },
+       { WERR_NERR_INVALIDLOGSEEK, "The log file does not contain the requested record number." },
+       { WERR_NERR_BADUASCONFIG, "The user accounts database is not configured correctly." },
+       { WERR_NERR_INVALIDUASOP, "This operation is not permitted when the Net Logon service is running." },
+       { WERR_NERR_LASTADMIN, "This operation is not allowed on the last administrative account." },
+       { WERR_NERR_DCNOTFOUND, "Could not find the domain controller for this domain." },
+       { WERR_NERR_LOGONTRACKINGERROR, "Could not set logon information for this user." },
+       { WERR_NERR_NETLOGONNOTSTARTED, "The Net Logon service has not been started." },
+       { WERR_NERR_CANNOTGROWUASFILE, "Unable to add to the user accounts database." },
+       { WERR_NERR_TIMEDIFFATDC, "This server\'s clock is not synchronized with the PDC\'s clock." },
+       { WERR_NERR_PASSWORDMISMATCH, "A password mismatch has been detected." },
+       { WERR_NERR_NOSUCHSERVER, "The server identification does not specify a valid server." },
+       { WERR_NERR_NOSUCHSESSION, "The session identification does not specify a valid session." },
+       { WERR_NERR_NOSUCHCONNECTION, "The connection identification does not specify a valid connection." },
+       { WERR_NERR_TOOMANYSERVERS, "There is no space for another entry in the table of available servers." },
+       { WERR_NERR_TOOMANYSESSIONS, "The server has reached the maximum number of sessions it supports." },
+       { WERR_NERR_TOOMANYCONNECTIONS, "The server has reached the maximum number of connections it supports." },
+       { WERR_NERR_TOOMANYFILES, "The server cannot open more files because it has reached its maximum number." },
+       { WERR_NERR_NOALTERNATESERVERS, "There are no alternate servers registered on this server." },
+       { WERR_NERR_TRYDOWNLEVEL, "Try the down-level (remote admin protocol) version of API instead." },
+       { WERR_NERR_UPSDRIVERNOTSTARTED, "The uninterruptible power supply (UPS) driver could not be accessed by the UPS service." },
+       { WERR_NERR_UPSINVALIDCONFIG, "The UPS service is not configured correctly." },
+       { WERR_NERR_UPSINVALIDCOMMPORT, "The UPS service could not access the specified Comm Port." },
+       { WERR_NERR_UPSSIGNALASSERTED, "The UPS indicated a line fail or low battery situation. Service not started." },
+       { WERR_NERR_UPSSHUTDOWNFAILED, "The UPS service failed to perform a system shut down." },
+       { WERR_NERR_BADDOSRETCODE, "The program below returned an MS-DOS error code." },
+       { WERR_NERR_PROGNEEDSEXTRAMEM, "The program below needs more memory." },
+       { WERR_NERR_BADDOSFUNCTION, "The program below called an unsupported MS-DOS function." },
+       { WERR_NERR_REMOTEBOOTFAILED, "The workstation failed to boot." },
+       { WERR_NERR_BADFILECHECKSUM, "The file below is corrupt." },
+       { WERR_NERR_NORPLBOOTSYSTEM, "No loader is specified in the boot-block definition file." },
+       { WERR_NERR_RPLLOADRNETBIOSERR, "NetBIOS returned an error: The network control blocks (NCBs) and Server Message Block (SMB) are dumped above." },
+       { WERR_NERR_RPLLOADRDISKERR, "A disk I/O error occurred." },
+       { WERR_NERR_IMAGEPARAMERR, "Image parameter substitution failed." },
+       { WERR_NERR_TOOMANYIMAGEPARAMS, "Too many image parameters cross disk sector boundaries." },
+       { WERR_NERR_NONDOSFLOPPYUSED, "The image was not generated from an MS-DOS disk formatted with /S." },
+       { WERR_NERR_RPLBOOTRESTART, "Remote boot will be restarted later." },
+       { WERR_NERR_RPLSRVRCALLFAILED, "The call to the Remoteboot server failed." },
+       { WERR_NERR_CANTCONNECTRPLSRVR, "Cannot connect to the Remoteboot server." },
+       { WERR_NERR_CANTOPENIMAGEFILE, "Cannot open image file on the Remoteboot server." },
+       { WERR_NERR_CALLINGRPLSRVR, "Connecting to the Remoteboot server." },
+       { WERR_NERR_STARTINGRPLBOOT, "Connecting to the Remoteboot server." },
+       { WERR_NERR_RPLBOOTSERVICETERM, "Remote boot service was stopped, check the error log for the cause of the problem." },
+       { WERR_NERR_RPLBOOTSTARTFAILED, "Remote boot startup failed; check the error log for the cause of the problem." },
+       { WERR_NERR_RPL_CONNECTED, "A second connection to a Remoteboot resource is not allowed." },
+       { WERR_NERR_BROWSERCONFIGUREDTONOTRUN, "The browser service was configured with MaintainServerList=No." },
+       { WERR_NERR_RPLNOADAPTERSSTARTED, "Service failed to start because none of the network adapters started with this service." },
+       { WERR_NERR_RPLBADREGISTRY, "Service failed to start due to bad startup information in the registry." },
+       { WERR_NERR_RPLBADDATABASE, "Service failed to start because its database is absent or corrupt." },
+       { WERR_NERR_RPLRPLFILESSHARE, "Service failed to start because the RPLFILES share is absent." },
+       { WERR_NERR_RPLNOTRPLSERVER, "Service failed to start because the RPLUSER group is absent." },
+       { WERR_NERR_RPLCANNOTENUM, "Cannot enumerate service records." },
+       { WERR_NERR_RPLWKSTAINFOCORRUPTED, "Workstation record information has been corrupted." },
+       { WERR_NERR_RPLWKSTANOTFOUND, "Workstation record was not found." },
+       { WERR_NERR_RPLWKSTANAMEUNAVAILABLE, "Workstation name is in use by some other workstation." },
+       { WERR_NERR_RPLPROFILEINFOCORRUPTED, "Profile record information has been corrupted." },
+       { WERR_NERR_RPLPROFILENOTFOUND, "Profile record was not found." },
+       { WERR_NERR_RPLPROFILENAMEUNAVAILABLE, "Profile name is in use by some other profile." },
+       { WERR_NERR_RPLPROFILENOTEMPTY, "There are workstations using this profile." },
+       { WERR_NERR_RPLCONFIGINFOCORRUPTED, "Configuration record information has been corrupted." },
+       { WERR_NERR_RPLCONFIGNOTFOUND, "Configuration record was not found." },
+       { WERR_NERR_RPLADAPTERINFOCORRUPTED, "Adapter ID record information has been corrupted." },
+       { WERR_NERR_RPLINTERNAL, "An internal service error has occurred." },
+       { WERR_NERR_RPLVENDORINFOCORRUPTED, "Vendor ID record information has been corrupted." },
+       { WERR_NERR_RPLBOOTINFOCORRUPTED, "Boot block record information has been corrupted." },
+       { WERR_NERR_RPLWKSTANEEDSUSERACCT, "The user account for this workstation record is missing." },
+       { WERR_NERR_RPLNEEDSRPLUSERACCT, "The RPLUSER local group could not be found." },
+       { WERR_NERR_RPLBOOTNOTFOUND, "Boot block record was not found." },
+       { WERR_NERR_RPLINCOMPATIBLEPROFILE, "Chosen profile is incompatible with this workstation." },
+       { WERR_NERR_RPLADAPTERNAMEUNAVAILABLE, "Chosen network adapter ID is in use by some other workstation." },
+       { WERR_NERR_RPLCONFIGNOTEMPTY, "There are profiles using this configuration." },
+       { WERR_NERR_RPLBOOTINUSE, "There are workstations, profiles, or configurations using this boot block." },
+       { WERR_NERR_RPLBACKUPDATABASE, "Service failed to back up the Remoteboot database." },
+       { WERR_NERR_RPLADAPTERNOTFOUND, "Adapter record was not found." },
+       { WERR_NERR_RPLVENDORNOTFOUND, "Vendor record was not found." },
+       { WERR_NERR_RPLVENDORNAMEUNAVAILABLE, "Vendor name is in use by some other vendor record." },
+       { WERR_NERR_RPLBOOTNAMEUNAVAILABLE, "The boot name or vendor ID is in use by some other boot block record." },
+       { WERR_NERR_RPLCONFIGNAMEUNAVAILABLE, "The configuration name is in use by some other configuration." },
+       { WERR_NERR_DFSINTERNALCORRUPTION, "The internal database maintained by the DFS service is corrupt." },
+       { WERR_NERR_DFSVOLUMEDATACORRUPT, "One of the records in the internal DFS database is corrupt." },
+       { WERR_NERR_DFSNOSUCHVOLUME, "There is no DFS name whose entry path matches the input entry path." },
+       { WERR_NERR_DFSVOLUMEALREADYEXISTS, "A root or link with the given name already exists." },
+       { WERR_NERR_DFSALREADYSHARED, "The server share specified is already shared in the DFS." },
+       { WERR_NERR_DFSNOSUCHSHARE, "The indicated server share does not support the indicated DFS namespace." },
+       { WERR_NERR_DFSNOTALEAFVOLUME, "The operation is not valid in this portion of the namespace." },
+       { WERR_NERR_DFSLEAFVOLUME, "The operation is not valid in this portion of the namespace." },
+       { WERR_NERR_DFSVOLUMEHASMULTIPLESERVERS, "The operation is ambiguous because the link has multiple servers." },
+       { WERR_NERR_DFSCANTCREATEJUNCTIONPOINT, "Unable to create a link." },
+       { WERR_NERR_DFSSERVERNOTDFSAWARE, "The server is not DFS-aware." },
+       { WERR_NERR_DFSBADRENAMEPATH, "The specified rename target path is invalid." },
+       { WERR_NERR_DFSVOLUMEISOFFLINE, "The specified DFS link is offline." },
+       { WERR_NERR_DFSNOSUCHSERVER, "The specified server is not a server for this link." },
+       { WERR_NERR_DFSCYCLICALNAME, "A cycle in the DFS name was detected." },
+       { WERR_NERR_DFSNOTSUPPORTEDINSERVERDFS, "The operation is not supported on a server-based DFS." },
+       { WERR_NERR_DFSDUPLICATESERVICE, "This link is already supported by the specified server share." },
+       { WERR_NERR_DFSCANTREMOVELASTSERVERSHARE, "Cannot remove the last server share supporting this root or link." },
+       { WERR_NERR_DFSVOLUMEISINTERDFS, "The operation is not supported for an inter-DFS link." },
+       { WERR_NERR_DFSINCONSISTENT, "The internal state of the DFS Service has become inconsistent." },
+       { WERR_NERR_DFSSERVERUPGRADED, "The DFS Service has been installed on the specified server." },
+       { WERR_NERR_DFSDATAISIDENTICAL, "The DFS data being reconciled is identical." },
+       { WERR_NERR_DFSCANTREMOVEDFSROOT, "The DFS root cannot be deleted. Uninstall DFS if required." },
+       { WERR_NERR_DFSCHILDORPARENTINDFS, "A child or parent directory of the share is already in a DFS." },
+       { WERR_NERR_DFSINTERNALERROR, "DFS internal error." },
+       { WERR_NERR_SETUPALREADYJOINED, "This machine is already joined to a domain." },
+       { WERR_NERR_SETUPNOTJOINED, "This machine is not currently joined to a domain." },
+       { WERR_NERR_SETUPDOMAINCONTROLLER, "This machine is a domain controller and cannot be unjoined from a domain." },
+       { WERR_NERR_DEFAULTJOINREQUIRED, "The destination domain controller does not support creating machine accounts in organizational units (OUs)." },
+       { WERR_NERR_INVALIDWORKGROUPNAME, "The specified workgroup name is invalid." },
+       { WERR_NERR_NAMEUSESINCOMPATIBLECODEPAGE, "The specified computer name is incompatible with the default language used on the domain controller." },
+       { WERR_NERR_COMPUTERACCOUNTNOTFOUND, "The specified computer account could not be found." },
+       { WERR_NERR_PERSONALSKU, "This version of Windows cannot be joined to a domain." },
+       { WERR_NERR_PASSWORDMUSTCHANGE, "The password must change at the next logon." },
+       { WERR_NERR_ACCOUNTLOCKEDOUT, "The account is locked out." },
+       { WERR_NERR_PASSWORDTOOLONG, "The password is too long." },
+       { WERR_NERR_PASSWORDNOTCOMPLEXENOUGH, "The password does not meet the complexity policy." },
+       { WERR_NERR_PASSWORDFILTERERROR, "The password does not meet the requirements of the password filter DLLs." },
+       { WERR_UNKNOWN_PRINT_MONITOR, "The specified print monitor is unknown." },
+       { WERR_PRINTER_DRIVER_IN_USE, "The specified printer driver is currently in use." },
+       { WERR_SPOOL_FILE_NOT_FOUND, "The spool file was not found." },
+       { WERR_SPL_NO_STARTDOC, "A StartDocPrinter call was not issued." },
+       { WERR_SPL_NO_ADDJOB, "An AddJob call was not issued." },
+       { WERR_PRINT_PROCESSOR_ALREADY_INSTALLED, "The specified print processor has already been installed." },
+       { WERR_PRINT_MONITOR_ALREADY_INSTALLED, "The specified print monitor has already been installed." },
+       { WERR_INVALID_PRINT_MONITOR, "The specified print monitor does not have the required functions." },
+       { WERR_PRINT_MONITOR_IN_USE, "The specified print monitor is currently in use." },
+       { WERR_PRINTER_HAS_JOBS_QUEUED, "The requested operation is not allowed when there are jobs queued to the printer." },
+       { WERR_SUCCESS_REBOOT_REQUIRED, "The requested operation is successful. Changes will not be effective until the system is rebooted." },
+       { WERR_SUCCESS_RESTART_REQUIRED, "The requested operation is successful. Changes will not be effective until the service is restarted." },
+       { WERR_PRINTER_NOT_FOUND, "No printers were found." },
+       { WERR_PRINTER_DRIVER_WARNED, "The printer driver is known to be unreliable." },
+       { WERR_PRINTER_DRIVER_BLOCKED, "The printer driver is known to harm the system." },
+       { WERR_PRINTER_DRIVER_PACKAGE_IN_USE, "The specified printer driver package is currently in use." },
+       { WERR_CORE_DRIVER_PACKAGE_NOT_FOUND, "Unable to find a core driver package that is required by the printer driver package." },
+       { WERR_FAIL_REBOOT_REQUIRED, "The requested operation failed. A system reboot is required to roll back changes made." },
+       { WERR_FAIL_REBOOT_INITIATED, "The requested operation failed. A system reboot has been initiated to roll back changes made." },
+       { WERR_IO_REISSUE_AS_CACHED, "Reissue the given operation as a cached I/O operation" },
+       { WERR_WINS_INTERNAL, "Windows Internet Name Service (WINS) encountered an error while processing the command." },
+       { WERR_CAN_NOT_DEL_LOCAL_WINS, "The local WINS cannot be deleted." },
+       { WERR_STATIC_INIT, "The importation from the file failed." },
+       { WERR_INC_BACKUP, "The backup failed. Was a full backup done before?" },
+       { WERR_FULL_BACKUP, "The backup failed. Check the directory to which you are backing the database." },
+       { WERR_REC_NON_EXISTENT, "The name does not exist in the WINS database." },
+       { WERR_RPL_NOT_ALLOWED, "Replication with a nonconfigured partner is not allowed." },
+       { WERR_DHCP_ADDRESS_CONFLICT, "The Dynamic Host Configuration Protocol (DHCP) client has obtained an IP address that is already in use on the network. The local interface will be disabled until the DHCP client can obtain a new address." },
+       { WERR_WMI_GUID_NOT_FOUND, "The GUID passed was not recognized as valid by a WMI data provider." },
+       { WERR_WMI_INSTANCE_NOT_FOUND, "The instance name passed was not recognized as valid by a WMI data provider." },
+       { WERR_WMI_ITEMID_NOT_FOUND, "The data item ID passed was not recognized as valid by a WMI data provider." },
+       { WERR_WMI_TRY_AGAIN, "The WMI request could not be completed and should be retried." },
+       { WERR_WMI_DP_NOT_FOUND, "The WMI data provider could not be located." },
+       { WERR_WMI_UNRESOLVED_INSTANCE_REF, "The WMI data provider references an instance set that has not been registered." },
+       { WERR_WMI_ALREADY_ENABLED, "The WMI data block or event notification has already been enabled." },
+       { WERR_WMI_GUID_DISCONNECTED, "The WMI data block is no longer available." },
+       { WERR_WMI_SERVER_UNAVAILABLE, "The WMI data service is not available." },
+       { WERR_WMI_DP_FAILED, "The WMI data provider failed to carry out the request." },
+       { WERR_WMI_INVALID_MOF, "The WMI Managed Object Format (MOF) information is not valid." },
+       { WERR_WMI_INVALID_REGINFO, "The WMI registration information is not valid." },
+       { WERR_WMI_ALREADY_DISABLED, "The WMI data block or event notification has already been disabled." },
+       { WERR_WMI_READ_ONLY, "The WMI data item or data block is read-only." },
+       { WERR_WMI_SET_FAILURE, "The WMI data item or data block could not be changed." },
+       { WERR_INVALID_MEDIA, "The media identifier does not represent a valid medium." },
+       { WERR_INVALID_LIBRARY, "The library identifier does not represent a valid library." },
+       { WERR_INVALID_MEDIA_POOL, "The media pool identifier does not represent a valid media pool." },
+       { WERR_DRIVE_MEDIA_MISMATCH, "The drive and medium are not compatible, or they exist in different libraries." },
+       { WERR_MEDIA_OFFLINE, "The medium currently exists in an offline library and must be online to perform this operation." },
+       { WERR_LIBRARY_OFFLINE, "The operation cannot be performed on an offline library." },
+       { WERR_EMPTY, "The library, drive, or media pool is empty." },
+       { WERR_NOT_EMPTY, "The library, drive, or media pool must be empty to perform this operation." },
+       { WERR_MEDIA_UNAVAILABLE, "No media is currently available in this media pool or library." },
+       { WERR_RESOURCE_DISABLED, "A resource required for this operation is disabled." },
+       { WERR_INVALID_CLEANER, "The media identifier does not represent a valid cleaner." },
+       { WERR_UNABLE_TO_CLEAN, "The drive cannot be cleaned or does not support cleaning." },
+       { WERR_OBJECT_NOT_FOUND, "The object identifier does not represent a valid object." },
+       { WERR_DATABASE_FAILURE, "Unable to read from or write to the database." },
+       { WERR_DATABASE_FULL, "The database is full." },
+       { WERR_MEDIA_INCOMPATIBLE, "The medium is not compatible with the device or media pool." },
+       { WERR_RESOURCE_NOT_PRESENT, "The resource required for this operation does not exist." },
+       { WERR_INVALID_OPERATION, "The operation identifier is not valid." },
+       { WERR_MEDIA_NOT_AVAILABLE, "The media is not mounted or ready for use." },
+       { WERR_DEVICE_NOT_AVAILABLE, "The device is not ready for use." },
+       { WERR_REQUEST_REFUSED, "The operator or administrator has refused the request." },
+       { WERR_INVALID_DRIVE_OBJECT, "The drive identifier does not represent a valid drive." },
+       { WERR_LIBRARY_FULL, "Library is full. No slot is available for use." },
+       { WERR_MEDIUM_NOT_ACCESSIBLE, "The transport cannot access the medium." },
+       { WERR_UNABLE_TO_LOAD_MEDIUM, "Unable to load the medium into the drive." },
+       { WERR_UNABLE_TO_INVENTORY_DRIVE, "Unable to retrieve the drive status." },
+       { WERR_UNABLE_TO_INVENTORY_SLOT, "Unable to retrieve the slot status." },
+       { WERR_UNABLE_TO_INVENTORY_TRANSPORT, "Unable to retrieve status about the transport." },
+       { WERR_TRANSPORT_FULL, "Cannot use the transport because it is already in use." },
+       { WERR_CONTROLLING_IEPORT, "Unable to open or close the inject/eject port." },
+       { WERR_UNABLE_TO_EJECT_MOUNTED_MEDIA, "Unable to eject the medium because it is in a drive." },
+       { WERR_CLEANER_SLOT_SET, "A cleaner slot is already reserved." },
+       { WERR_CLEANER_SLOT_NOT_SET, "A cleaner slot is not reserved." },
+       { WERR_CLEANER_CARTRIDGE_SPENT, "The cleaner cartridge has performed the maximum number of drive cleanings." },
+       { WERR_UNEXPECTED_OMID, "Unexpected on-medium identifier." },
+       { WERR_CANT_DELETE_LAST_ITEM, "The last remaining item in this group or resource cannot be deleted." },
+       { WERR_MESSAGE_EXCEEDS_MAX_SIZE, "The message provided exceeds the maximum size allowed for this parameter." },
+       { WERR_VOLUME_CONTAINS_SYS_FILES, "The volume contains system or paging files." },
+       { WERR_INDIGENOUS_TYPE, "The media type cannot be removed from this library because at least one drive in the library reports it can support this media type." },
+       { WERR_NO_SUPPORTING_DRIVES, "This offline media cannot be mounted on this system because no enabled drives are present that can be used." },
+       { WERR_CLEANER_CARTRIDGE_INSTALLED, "A cleaner cartridge is present in the tape library." },
+       { WERR_IEPORT_FULL, "Cannot use the IEport because it is not empty." },
+       { WERR_FILE_OFFLINE, "The remote storage service was not able to recall the file." },
+       { WERR_REMOTE_STORAGE_NOT_ACTIVE, "The remote storage service is not operational at this time." },
+       { WERR_REMOTE_STORAGE_MEDIA_ERROR, "The remote storage service encountered a media error." },
+       { WERR_NOT_A_REPARSE_POINT, "The file or directory is not a reparse point." },
+       { WERR_REPARSE_ATTRIBUTE_CONFLICT, "The reparse point attribute cannot be set because it conflicts with an existing attribute." },
+       { WERR_INVALID_REPARSE_DATA, "The data present in the reparse point buffer is invalid." },
+       { WERR_REPARSE_TAG_INVALID, "The tag present in the reparse point buffer is invalid." },
+       { WERR_REPARSE_TAG_MISMATCH, "There is a mismatch between the tag specified in the request and the tag present in the reparse point." },
+       { WERR_VOLUME_NOT_SIS_ENABLED, "Single Instance Storage (SIS) is not available on this volume." },
+       { WERR_DEPENDENT_RESOURCE_EXISTS, "The operation cannot be completed because other resources depend on this resource." },
+       { WERR_DEPENDENCY_NOT_FOUND, "The cluster resource dependency cannot be found." },
+       { WERR_DEPENDENCY_ALREADY_EXISTS, "The cluster resource cannot be made dependent on the specified resource because it is already dependent." },
+       { WERR_RESOURCE_NOT_ONLINE, "The cluster resource is not online." },
+       { WERR_HOST_NODE_NOT_AVAILABLE, "A cluster node is not available for this operation." },
+       { WERR_RESOURCE_NOT_AVAILABLE, "The cluster resource is not available." },
+       { WERR_RESOURCE_NOT_FOUND, "The cluster resource could not be found." },
+       { WERR_SHUTDOWN_CLUSTER, "The cluster is being shut down." },
+       { WERR_CANT_EVICT_ACTIVE_NODE, "A cluster node cannot be evicted from the cluster unless the node is down or it is the last node." },
+       { WERR_OBJECT_ALREADY_EXISTS, "The object already exists." },
+       { WERR_OBJECT_IN_LIST, "The object is already in the list." },
+       { WERR_GROUP_NOT_AVAILABLE, "The cluster group is not available for any new requests." },
+       { WERR_GROUP_NOT_FOUND, "The cluster group could not be found." },
+       { WERR_GROUP_NOT_ONLINE, "The operation could not be completed because the cluster group is not online." },
+       { WERR_HOST_NODE_NOT_RESOURCE_OWNER, "The operation failed because either the specified cluster node is not the owner of the resource, or the node is not a possible owner of the resource." },
+       { WERR_HOST_NODE_NOT_GROUP_OWNER, "The operation failed because either the specified cluster node is not the owner of the group, or the node is not a possible owner of the group." },
+       { WERR_RESMON_CREATE_FAILED, "The cluster resource could not be created in the specified resource monitor." },
+       { WERR_RESMON_ONLINE_FAILED, "The cluster resource could not be brought online by the resource monitor." },
+       { WERR_RESOURCE_ONLINE, "The operation could not be completed because the cluster resource is online." },
+       { WERR_QUORUM_RESOURCE, "The cluster resource could not be deleted or brought offline because it is the quorum resource." },
+       { WERR_NOT_QUORUM_CAPABLE, "The cluster could not make the specified resource a quorum resource because it is not capable of being a quorum resource." },
+       { WERR_CLUSTER_SHUTTING_DOWN, "The cluster software is shutting down." },
+       { WERR_INVALID_STATE, "The group or resource is not in the correct state to perform the requested operation." },
+       { WERR_RESOURCE_PROPERTIES_STORED, "The properties were stored but not all changes will take effect until the next time the resource is brought online." },
+       { WERR_NOT_QUORUM_CLASS, "The cluster could not make the specified resource a quorum resource because it does not belong to a shared storage class." },
+       { WERR_CORE_RESOURCE, "The cluster resource could not be deleted because it is a core resource." },
+       { WERR_QUORUM_RESOURCE_ONLINE_FAILED, "The quorum resource failed to come online." },
+       { WERR_QUORUMLOG_OPEN_FAILED, "The quorum log could not be created or mounted successfully." },
+       { WERR_CLUSTERLOG_CORRUPT, "The cluster log is corrupt." },
+       { WERR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE, "The record could not be written to the cluster log because it exceeds the maximum size." },
+       { WERR_CLUSTERLOG_EXCEEDS_MAXSIZE, "The cluster log exceeds its maximum size." },
+       { WERR_CLUSTERLOG_CHKPOINT_NOT_FOUND, "No checkpoint record was found in the cluster log." },
+       { WERR_CLUSTERLOG_NOT_ENOUGH_SPACE, "The minimum required disk space needed for logging is not available." },
+       { WERR_QUORUM_OWNER_ALIVE, "The cluster node failed to take control of the quorum resource because the resource is owned by another active node." },
+       { WERR_NETWORK_NOT_AVAILABLE, "A cluster network is not available for this operation." },
+       { WERR_NODE_NOT_AVAILABLE, "A cluster node is not available for this operation." },
+       { WERR_ALL_NODES_NOT_AVAILABLE, "All cluster nodes must be running to perform this operation." },
+       { WERR_RESOURCE_FAILED, "A cluster resource failed." },
+       { WERR_CLUSTER_INVALID_NODE, "The cluster node is not valid." },
+       { WERR_CLUSTER_NODE_EXISTS, "The cluster node already exists." },
+       { WERR_CLUSTER_JOIN_IN_PROGRESS, "A node is in the process of joining the cluster." },
+       { WERR_CLUSTER_NODE_NOT_FOUND, "The cluster node was not found." },
+       { WERR_CLUSTER_LOCAL_NODE_NOT_FOUND, "The cluster local node information was not found." },
+       { WERR_CLUSTER_NETWORK_EXISTS, "The cluster network already exists." },
+       { WERR_CLUSTER_NETWORK_NOT_FOUND, "The cluster network was not found." },
+       { WERR_CLUSTER_NETINTERFACE_EXISTS, "The cluster network interface already exists." },
+       { WERR_CLUSTER_NETINTERFACE_NOT_FOUND, "The cluster network interface was not found." },
+       { WERR_CLUSTER_INVALID_REQUEST, "The cluster request is not valid for this object." },
+       { WERR_CLUSTER_INVALID_NETWORK_PROVIDER, "The cluster network provider is not valid." },
+       { WERR_CLUSTER_NODE_DOWN, "The cluster node is down." },
+       { WERR_CLUSTER_NODE_UNREACHABLE, "The cluster node is not reachable." },
+       { WERR_CLUSTER_NODE_NOT_MEMBER, "The cluster node is not a member of the cluster." },
+       { WERR_CLUSTER_JOIN_NOT_IN_PROGRESS, "A cluster join operation is not in progress." },
+       { WERR_CLUSTER_INVALID_NETWORK, "The cluster network is not valid." },
+       { WERR_CLUSTER_NODE_UP, "The cluster node is up." },
+       { WERR_CLUSTER_IPADDR_IN_USE, "The cluster IP address is already in use." },
+       { WERR_CLUSTER_NODE_NOT_PAUSED, "The cluster node is not paused." },
+       { WERR_CLUSTER_NO_SECURITY_CONTEXT, "No cluster security context is available." },
+       { WERR_CLUSTER_NETWORK_NOT_INTERNAL, "The cluster network is not configured for internal cluster communication." },
+       { WERR_CLUSTER_NODE_ALREADY_UP, "The cluster node is already up." },
+       { WERR_CLUSTER_NODE_ALREADY_DOWN, "The cluster node is already down." },
+       { WERR_CLUSTER_NETWORK_ALREADY_ONLINE, "The cluster network is already online." },
+       { WERR_CLUSTER_NETWORK_ALREADY_OFFLINE, "The cluster network is already offline." },
+       { WERR_CLUSTER_NODE_ALREADY_MEMBER, "The cluster node is already a member of the cluster." },
+       { WERR_CLUSTER_LAST_INTERNAL_NETWORK, "The cluster network is the only one configured for internal cluster communication between two or more active cluster nodes. The internal communication capability cannot be removed from the network." },
+       { WERR_CLUSTER_NETWORK_HAS_DEPENDENTS, "One or more cluster resources depend on the network to provide service to clients. The client access capability cannot be removed from the network." },
+       { WERR_INVALID_OPERATION_ON_QUORUM, "This operation cannot be performed on the cluster resource because it is the quorum resource. You may not bring the quorum resource offline or modify its possible owners list." },
+       { WERR_DEPENDENCY_NOT_ALLOWED, "The cluster quorum resource is not allowed to have any dependencies." },
+       { WERR_CLUSTER_NODE_PAUSED, "The cluster node is paused." },
+       { WERR_NODE_CANT_HOST_RESOURCE, "The cluster resource cannot be brought online. The owner node cannot run this resource." },
+       { WERR_CLUSTER_NODE_NOT_READY, "The cluster node is not ready to perform the requested operation." },
+       { WERR_CLUSTER_NODE_SHUTTING_DOWN, "The cluster node is shutting down." },
+       { WERR_CLUSTER_JOIN_ABORTED, "The cluster join operation was aborted." },
+       { WERR_CLUSTER_INCOMPATIBLE_VERSIONS, "The cluster join operation failed due to incompatible software versions between the joining node and its sponsor." },
+       { WERR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED, "This resource cannot be created because the cluster has reached the limit on the number of resources it can monitor." },
+       { WERR_CLUSTER_SYSTEM_CONFIG_CHANGED, "The system configuration changed during the cluster join or form operation. The join or form operation was aborted." },
+       { WERR_CLUSTER_RESOURCE_TYPE_NOT_FOUND, "The specified resource type was not found." },
+       { WERR_CLUSTER_RESTYPE_NOT_SUPPORTED, "The specified node does not support a resource of this type. This may be due to version inconsistencies or due to the absence of the resource DLL on this node." },
+       { WERR_CLUSTER_RESNAME_NOT_FOUND, "The specified resource name is not supported by this resource DLL. This may be due to a bad (or changed) name supplied to the resource DLL." },
+       { WERR_CLUSTER_NO_RPC_PACKAGES_REGISTERED, "No authentication package could be registered with the RPC server." },
+       { WERR_CLUSTER_OWNER_NOT_IN_PREFLIST, "You cannot bring the group online because the owner of the group is not in the preferred list for the group. To change the owner node for the group, move the group." },
+       { WERR_CLUSTER_DATABASE_SEQMISMATCH, "The join operation failed because the cluster database sequence number has changed or is incompatible with the locker node. This may happen during a join operation if the cluster database was changing during the join." },
+       { WERR_RESMON_INVALID_STATE, "The resource monitor will not allow the fail operation to be performed while the resource is in its current state. This may happen if the resource is in a pending state." },
+       { WERR_CLUSTER_GUM_NOT_LOCKER, "A non-locker code received a request to reserve the lock for making global updates." },
+       { WERR_QUORUM_DISK_NOT_FOUND, "The quorum disk could not be located by the cluster service." },
+       { WERR_DATABASE_BACKUP_CORRUPT, "The backed-up cluster database is possibly corrupt." },
+       { WERR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT, "A DFS root already exists in this cluster node." },
+       { WERR_RESOURCE_PROPERTY_UNCHANGEABLE, "An attempt to modify a resource property failed because it conflicts with another existing property." },
+       { WERR_CLUSTER_MEMBERSHIP_INVALID_STATE, "An operation was attempted that is incompatible with the current membership state of the node." },
+       { WERR_CLUSTER_QUORUMLOG_NOT_FOUND, "The quorum resource does not contain the quorum log." },
+       { WERR_CLUSTER_MEMBERSHIP_HALT, "The membership engine requested shutdown of the cluster service on this node." },
+       { WERR_CLUSTER_INSTANCE_ID_MISMATCH, "The join operation failed because the cluster instance ID of the joining node does not match the cluster instance ID of the sponsor node." },
+       { WERR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP, "A matching cluster network for the specified IP address could not be found." },
+       { WERR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH, "The actual data type of the property did not match the expected data type of the property." },
+       { WERR_CLUSTER_EVICT_WITHOUT_CLEANUP, "The cluster node was evicted from the cluster successfully, but the node was not cleaned up. To determine what clean-up steps failed and how to recover, see the Failover Clustering application event log using Event Viewer." },
+       { WERR_CLUSTER_PARAMETER_MISMATCH, "Two or more parameter values specified for a resource\'s properties are in conflict." },
+       { WERR_NODE_CANNOT_BE_CLUSTERED, "This computer cannot be made a member of a cluster." },
+       { WERR_CLUSTER_WRONG_OS_VERSION, "This computer cannot be made a member of a cluster because it does not have the correct version of Windows installed." },
+       { WERR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME, "A cluster cannot be created with the specified cluster name because that cluster name is already in use. Specify a different name for the cluster." },
+       { WERR_CLUSCFG_ALREADY_COMMITTED, "The cluster configuration action has already been committed." },
+       { WERR_CLUSCFG_ROLLBACK_FAILED, "The cluster configuration action could not be rolled back." },
+       { WERR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT, "The drive letter assigned to a system disk on one node conflicted with the drive letter assigned to a disk on another node." },
+       { WERR_CLUSTER_OLD_VERSION, "One or more nodes in the cluster are running a version of Windows that does not support this operation." },
+       { WERR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME, "The name of the corresponding computer account does not match the network name for this resource." },
+       { WERR_CLUSTER_NO_NET_ADAPTERS, "No network adapters are available." },
+       { WERR_CLUSTER_POISONED, "The cluster node has been poisoned." },
+       { WERR_CLUSTER_GROUP_MOVING, "The group is unable to accept the request because it is moving to another node." },
+       { WERR_CLUSTER_RESOURCE_TYPE_BUSY, "The resource type cannot accept the request because it is too busy performing another operation." },
+       { WERR_RESOURCE_CALL_TIMED_OUT, "The call to the cluster resource DLL timed out." },
+       { WERR_INVALID_CLUSTER_IPV6_ADDRESS, "The address is not valid for an IPv6 Address resource. A global IPv6 address is required, and it must match a cluster network. Compatibility addresses are not permitted." },
+       { WERR_CLUSTER_INTERNAL_INVALID_FUNCTION, "An internal cluster error occurred. A call to an invalid function was attempted." },
+       { WERR_CLUSTER_PARAMETER_OUT_OF_BOUNDS, "A parameter value is out of acceptable range." },
+       { WERR_CLUSTER_PARTIAL_SEND, "A network error occurred while sending data to another node in the cluster. The number of bytes transmitted was less than required." },
+       { WERR_CLUSTER_REGISTRY_INVALID_FUNCTION, "An invalid cluster registry operation was attempted." },
+       { WERR_CLUSTER_INVALID_STRING_TERMINATION, "An input string of characters is not properly terminated." },
+       { WERR_CLUSTER_INVALID_STRING_FORMAT, "An input string of characters is not in a valid format for the data it represents." },
+       { WERR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS, "An internal cluster error occurred. A cluster database transaction was attempted while a transaction was already in progress." },
+       { WERR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS, "An internal cluster error occurred. There was an attempt to commit a cluster database transaction while no transaction was in progress." },
+       { WERR_CLUSTER_NULL_DATA, "An internal cluster error occurred. Data was not properly initialized." },
+       { WERR_CLUSTER_PARTIAL_READ, "An error occurred while reading from a stream of data. An unexpected number of bytes was returned." },
+       { WERR_CLUSTER_PARTIAL_WRITE, "An error occurred while writing to a stream of data. The required number of bytes could not be written." },
+       { WERR_CLUSTER_CANT_DESERIALIZE_DATA, "An error occurred while deserializing a stream of cluster data." },
+       { WERR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT, "One or more property values for this resource are in conflict with one or more property values associated with its dependent resources." },
+       { WERR_CLUSTER_NO_QUORUM, "A quorum of cluster nodes was not present to form a cluster." },
+       { WERR_CLUSTER_INVALID_IPV6_NETWORK, "The cluster network is not valid for an IPv6 address resource, or it does not match the configured address." },
+       { WERR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK, "The cluster network is not valid for an IPv6 tunnel resource. Check the configuration of the IP Address resource on which the IPv6 tunnel resource depends." },
+       { WERR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP, "Quorum resource cannot reside in the available storage group." },
+       { WERR_ENCRYPTION_FAILED, "The specified file could not be encrypted." },
+       { WERR_DECRYPTION_FAILED, "The specified file could not be decrypted." },
+       { WERR_FILE_ENCRYPTED, "The specified file is encrypted and the user does not have the ability to decrypt it." },
+       { WERR_NO_RECOVERY_POLICY, "There is no valid encryption recovery policy configured for this system." },
+       { WERR_NO_EFS, "The required encryption driver is not loaded for this system." },
+       { WERR_WRONG_EFS, "The file was encrypted with a different encryption driver than is currently loaded." },
+       { WERR_NO_USER_KEYS, "There are no Encrypting File System (EFS) keys defined for the user." },
+       { WERR_FILE_NOT_ENCRYPTED, "The specified file is not encrypted." },
+       { WERR_NOT_EXPORT_FORMAT, "The specified file is not in the defined EFS export format." },
+       { WERR_FILE_READ_ONLY, "The specified file is read-only." },
+       { WERR_DIR_EFS_DISALLOWED, "The directory has been disabled for encryption." },
+       { WERR_EFS_SERVER_NOT_TRUSTED, "The server is not trusted for remote encryption operation." },
+       { WERR_BAD_RECOVERY_POLICY, "Recovery policy configured for this system contains invalid recovery certificate." },
+       { WERR_EFS_ALG_BLOB_TOO_BIG, "The encryption algorithm used on the source file needs a bigger key buffer than the one on the destination file." },
+       { WERR_VOLUME_NOT_SUPPORT_EFS, "The disk partition does not support file encryption." },
+       { WERR_EFS_DISABLED, "This machine is disabled for file encryption." },
+       { WERR_EFS_VERSION_NOT_SUPPORT, "A newer system is required to decrypt this encrypted file." },
+       { WERR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE, "The remote server sent an invalid response for a file being opened with client-side encryption." },
+       { WERR_CS_ENCRYPTION_UNSUPPORTED_SERVER, "Client-side encryption is not supported by the remote server even though it claims to support it." },
+       { WERR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE, "File is encrypted and should be opened in client-side encryption mode." },
+       { WERR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE, "A new encrypted file is being created and a $EFS needs to be provided." },
+       { WERR_CS_ENCRYPTION_FILE_NOT_CSE, "The SMB client requested a client-side extension (CSE) file system control (FSCTL) on a non-CSE file." },
+       { WERR_NO_BROWSER_SERVERS_FOUND, "The list of servers for this workgroup is not currently available" },
+       { WERR_LOG_SECTOR_INVALID, "The log service encountered an invalid log sector." },
+       { WERR_LOG_SECTOR_PARITY_INVALID, "The log service encountered a log sector with invalid block parity." },
+       { WERR_LOG_SECTOR_REMAPPED, "The log service encountered a remapped log sector." },
+       { WERR_LOG_BLOCK_INCOMPLETE, "The log service encountered a partial or incomplete log block." },
+       { WERR_LOG_INVALID_RANGE, "The log service encountered an attempt to access data outside the active log range." },
+       { WERR_LOG_BLOCKS_EXHAUSTED, "The log service user marshaling buffers are exhausted." },
+       { WERR_LOG_READ_CONTEXT_INVALID, "The log service encountered an attempt to read from a marshaling area with an invalid read context." },
+       { WERR_LOG_RESTART_INVALID, "The log service encountered an invalid log restart area." },
+       { WERR_LOG_BLOCK_VERSION, "The log service encountered an invalid log block version." },
+       { WERR_LOG_BLOCK_INVALID, "The log service encountered an invalid log block." },
+       { WERR_LOG_READ_MODE_INVALID, "The log service encountered an attempt to read the log with an invalid read mode." },
+       { WERR_LOG_NO_RESTART, "The log service encountered a log stream with no restart area." },
+       { WERR_LOG_METADATA_CORRUPT, "The log service encountered a corrupted metadata file." },
+       { WERR_LOG_METADATA_INVALID, "The log service encountered a metadata file that could not be created by the log file system." },
+       { WERR_LOG_METADATA_INCONSISTENT, "The log service encountered a metadata file with inconsistent data." },
+       { WERR_LOG_RESERVATION_INVALID, "The log service encountered an attempt to erroneous allocate or dispose reservation space." },
+       { WERR_LOG_CANT_DELETE, "The log service cannot delete a log file or file system container." },
+       { WERR_LOG_CONTAINER_LIMIT_EXCEEDED, "The log service has reached the maximum allowable containers allocated to a log file." },
+       { WERR_LOG_START_OF_LOG, "The log service has attempted to read or write backward past the start of the log." },
+       { WERR_LOG_POLICY_ALREADY_INSTALLED, "The log policy could not be installed because a policy of the same type is already present." },
+       { WERR_LOG_POLICY_NOT_INSTALLED, "The log policy in question was not installed at the time of the request." },
+       { WERR_LOG_POLICY_INVALID, "The installed set of policies on the log is invalid." },
+       { WERR_LOG_POLICY_CONFLICT, "A policy on the log in question prevented the operation from completing." },
+       { WERR_LOG_PINNED_ARCHIVE_TAIL, "Log space cannot be reclaimed because the log is pinned by the archive tail." },
+       { WERR_LOG_RECORD_NONEXISTENT, "The log record is not a record in the log file." },
+       { WERR_LOG_RECORDS_RESERVED_INVALID, "The number of reserved log records or the adjustment of the number of reserved log records is invalid." },
+       { WERR_LOG_SPACE_RESERVED_INVALID, "The reserved log space or the adjustment of the log space is invalid." },
+       { WERR_LOG_TAIL_INVALID, "A new or existing archive tail or base of the active log is invalid." },
+       { WERR_LOG_FULL, "The log space is exhausted." },
+       { WERR_COULD_NOT_RESIZE_LOG, "The log could not be set to the requested size." },
+       { WERR_LOG_MULTIPLEXED, "The log is multiplexed; no direct writes to the physical log are allowed." },
+       { WERR_LOG_DEDICATED, "The operation failed because the log is a dedicated log." },
+       { WERR_LOG_ARCHIVE_NOT_IN_PROGRESS, "The operation requires an archive context." },
+       { WERR_LOG_ARCHIVE_IN_PROGRESS, "Log archival is in progress." },
+       { WERR_LOG_EPHEMERAL, "The operation requires a non-ephemeral log, but the log is ephemeral." },
+       { WERR_LOG_NOT_ENOUGH_CONTAINERS, "The log must have at least two containers before it can be read from or written to." },
+       { WERR_LOG_CLIENT_ALREADY_REGISTERED, "A log client has already registered on the stream." },
+       { WERR_LOG_CLIENT_NOT_REGISTERED, "A log client has not been registered on the stream." },
+       { WERR_LOG_FULL_HANDLER_IN_PROGRESS, "A request has already been made to handle the log full condition." },
+       { WERR_LOG_CONTAINER_READ_FAILED, "The log service encountered an error when attempting to read from a log container." },
+       { WERR_LOG_CONTAINER_WRITE_FAILED, "The log service encountered an error when attempting to write to a log container." },
+       { WERR_LOG_CONTAINER_OPEN_FAILED, "The log service encountered an error when attempting to open a log container." },
+       { WERR_LOG_CONTAINER_STATE_INVALID, "The log service encountered an invalid container state when attempting a requested action." },
+       { WERR_LOG_STATE_INVALID, "The log service is not in the correct state to perform a requested action." },
+       { WERR_LOG_PINNED, "The log space cannot be reclaimed because the log is pinned." },
+       { WERR_LOG_METADATA_FLUSH_FAILED, "The log metadata flush failed." },
+       { WERR_LOG_INCONSISTENT_SECURITY, "Security on the log and its containers is inconsistent." },
+       { WERR_LOG_APPENDED_FLUSH_FAILED, "Records were appended to the log or reservation changes were made, but the log could not be flushed." },
+       { WERR_LOG_PINNED_RESERVATION, "The log is pinned due to reservation consuming most of the log space. Free some reserved records to make space available." },
+       { WERR_INVALID_TRANSACTION, "The transaction handle associated with this operation is not valid." },
+       { WERR_TRANSACTION_NOT_ACTIVE, "The requested operation was made in the context of a transaction that is no longer active." },
+       { WERR_TRANSACTION_REQUEST_NOT_VALID, "The requested operation is not valid on the transaction object in its current state." },
+       { WERR_TRANSACTION_NOT_REQUESTED, "The caller has called a response API, but the response is not expected because the transaction manager did not issue the corresponding request to the caller." },
+       { WERR_TRANSACTION_ALREADY_ABORTED, "It is too late to perform the requested operation because the transaction has already been aborted." },
+       { WERR_TRANSACTION_ALREADY_COMMITTED, "It is too late to perform the requested operation because the transaction has already been committed." },
+       { WERR_TM_INITIALIZATION_FAILED, "The transaction manager was unable to be successfully initialized. Transacted operations are not supported." },
+       { WERR_RESOURCEMANAGER_READ_ONLY, "The specified resource manager made no changes or updates to the resource under this transaction." },
+       { WERR_TRANSACTION_NOT_JOINED, "The resource manager has attempted to prepare a transaction that it has not successfully joined." },
+       { WERR_TRANSACTION_SUPERIOR_EXISTS, "The transaction object already has a superior enlistment, and the caller attempted an operation that would have created a new superior. Only a single superior enlistment is allowed." },
+       { WERR_CRM_PROTOCOL_ALREADY_EXISTS, "The resource manager tried to register a protocol that already exists." },
+       { WERR_TRANSACTION_PROPAGATION_FAILED, "The attempt to propagate the transaction failed." },
+       { WERR_CRM_PROTOCOL_NOT_FOUND, "The requested propagation protocol was not registered as a CRM." },
+       { WERR_TRANSACTION_INVALID_MARSHALL_BUFFER, "The buffer passed in to PushTransaction or PullTransaction is not in a valid format." },
+       { WERR_CURRENT_TRANSACTION_NOT_VALID, "The current transaction context associated with the thread is not a valid handle to a transaction object." },
+       { WERR_TRANSACTION_NOT_FOUND, "The specified transaction object could not be opened because it was not found." },
+       { WERR_RESOURCEMANAGER_NOT_FOUND, "The specified resource manager object could not be opened because it was not found." },
+       { WERR_ENLISTMENT_NOT_FOUND, "The specified enlistment object could not be opened because it was not found." },
+       { WERR_TRANSACTIONMANAGER_NOT_FOUND, "The specified transaction manager object could not be opened because it was not found." },
+       { WERR_TRANSACTIONMANAGER_NOT_ONLINE, "The specified resource manager was unable to create an enlistment because its associated transaction manager is not online." },
+       { WERR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION, "The specified transaction manager was unable to create the objects contained in its log file in the ObjectB namespace. Therefore, the transaction manager was unable to recover." },
+       { WERR_TRANSACTIONAL_CONFLICT, "The function attempted to use a name that is reserved for use by another transaction." },
+       { WERR_RM_NOT_ACTIVE, "Transaction support within the specified file system resource manager is not started or was shut down due to an error." },
+       { WERR_RM_METADATA_CORRUPT, "The metadata of the resource manager has been corrupted. The resource manager will not function." },
+       { WERR_DIRECTORY_NOT_RM, "The specified directory does not contain a resource manager." },
+       { WERR_TRANSACTIONS_UNSUPPORTED_REMOTE, "The remote server or share does not support transacted file operations." },
+       { WERR_LOG_RESIZE_INVALID_SIZE, "The requested log size is invalid." },
+       { WERR_OBJECT_NO_LONGER_EXISTS, "The object (file, stream, link) corresponding to the handle has been deleted by a transaction savepoint rollback." },
+       { WERR_STREAM_MINIVERSION_NOT_FOUND, "The specified file miniversion was not found for this transacted file open." },
+       { WERR_STREAM_MINIVERSION_NOT_VALID, "The specified file miniversion was found but has been invalidated. The most likely cause is a transaction savepoint rollback." },
+       { WERR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION, "A miniversion may only be opened in the context of the transaction that created it." },
+       { WERR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT, "It is not possible to open a miniversion with modify access." },
+       { WERR_CANT_CREATE_MORE_STREAM_MINIVERSIONS, "It is not possible to create any more miniversions for this stream." },
+       { WERR_REMOTE_FILE_VERSION_MISMATCH, "The remote server sent mismatching version numbers or FID for a file opened with transactions." },
+       { WERR_HANDLE_NO_LONGER_VALID, "The handle has been invalidated by a transaction. The most likely cause is the presence of memory mapping on a file, or an open handle when the transaction ended or rolled back to savepoint." },
+       { WERR_NO_TXF_METADATA, "There is no transaction metadata on the file." },
+       { WERR_LOG_CORRUPTION_DETECTED, "The log data is corrupt." },
+       { WERR_CANT_RECOVER_WITH_HANDLE_OPEN, "The file cannot be recovered because a handle is still open on it." },
+       { WERR_RM_DISCONNECTED, "The transaction outcome is unavailable because the resource manager responsible for it is disconnected." },
+       { WERR_ENLISTMENT_NOT_SUPERIOR, "The request was rejected because the enlistment in question is not a superior enlistment." },
+       { WERR_RECOVERY_NOT_NEEDED, "The transactional resource manager is already consistent. Recovery is not needed." },
+       { WERR_RM_ALREADY_STARTED, "The transactional resource manager has already been started." },
+       { WERR_FILE_IDENTITY_NOT_PERSISTENT, "The file cannot be opened in a transaction because its identity depends on the outcome of an unresolved transaction." },
+       { WERR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY, "The operation cannot be performed because another transaction is depending on the fact that this property will not change." },
+       { WERR_CANT_CROSS_RM_BOUNDARY, "The operation would involve a single file with two transactional resource managers and is therefore not allowed." },
+       { WERR_TXF_DIR_NOT_EMPTY, "The $Txf directory must be empty for this operation to succeed." },
+       { WERR_INDOUBT_TRANSACTIONS_EXIST, "The operation would leave a transactional resource manager in an inconsistent state and is, therefore, not allowed." },
+       { WERR_TM_VOLATILE, "The operation could not be completed because the transaction manager does not have a log." },
+       { WERR_ROLLBACK_TIMER_EXPIRED, "A rollback could not be scheduled because a previously scheduled rollback has already been executed or is queued for execution." },
+       { WERR_TXF_ATTRIBUTE_CORRUPT, "The transactional metadata attribute on the file or directory is corrupt and unreadable." },
+       { WERR_EFS_NOT_ALLOWED_IN_TRANSACTION, "The encryption operation could not be completed because a transaction is active." },
+       { WERR_TRANSACTIONAL_OPEN_NOT_ALLOWED, "This object is not allowed to be opened in a transaction." },
+       { WERR_LOG_GROWTH_FAILED, "An attempt to create space in the transactional resource manager\'s log failed. The failure status has been recorded in the event log." },
+       { WERR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE, "Memory mapping (creating a mapped section) to a remote file under a transaction is not supported." },
+       { WERR_TXF_METADATA_ALREADY_PRESENT, "Transaction metadata is already present on this file and cannot be superseded." },
+       { WERR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET, "A transaction scope could not be entered because the scope handler has not been initialized." },
+       { WERR_TRANSACTION_REQUIRED_PROMOTION, "Promotion was required to allow the resource manager to enlist, but the transaction was set to disallow it." },
+       { WERR_CANNOT_EXECUTE_FILE_IN_TRANSACTION, "This file is open for modification in an unresolved transaction and may be opened for execution only by a transacted reader." },
+       { WERR_TRANSACTIONS_NOT_FROZEN, "The request to thaw frozen transactions was ignored because transactions were not previously frozen." },
+       { WERR_TRANSACTION_FREEZE_IN_PROGRESS, "Transactions cannot be frozen because a freeze is already in progress." },
+       { WERR_NOT_SNAPSHOT_VOLUME, "The target volume is not a snapshot volume. This operation is only valid on a volume mounted as a snapshot." },
+       { WERR_NO_SAVEPOINT_WITH_OPEN_FILES, "The savepoint operation failed because files are open on the transaction. This is not permitted." },
+       { WERR_DATA_LOST_REPAIR, "Windows has discovered corruption in a file, and that file has since been repaired. Data loss may have occurred." },
+       { WERR_SPARSE_NOT_ALLOWED_IN_TRANSACTION, "The sparse operation could not be completed because a transaction is active on the file." },
+       { WERR_TM_IDENTITY_MISMATCH, "The call to create a transaction manager object failed because the Tm Identity stored in the logfile does not match the Tm Identity that was passed in as an argument." },
+       { WERR_FLOATED_SECTION, "I/O was attempted on a section object that has been floated as a result of a transaction ending. There is no valid data." },
+       { WERR_CANNOT_ACCEPT_TRANSACTED_WORK, "The transactional resource manager cannot currently accept transacted work due to a transient condition, such as low resources." },
+       { WERR_CANNOT_ABORT_TRANSACTIONS, "The transactional resource manager had too many transactions outstanding that could not be aborted. The transactional resource manager has been shut down." },
+       { WERR_CTX_WINSTATION_NAME_INVALID, "The specified session name is invalid." },
+       { WERR_CTX_INVALID_PD, "The specified protocol driver is invalid." },
+       { WERR_CTX_PD_NOT_FOUND, "The specified protocol driver was not found in the system path." },
+       { WERR_CTX_WD_NOT_FOUND, "The specified terminal connection driver was not found in the system path." },
+       { WERR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY, "A registry key for event logging could not be created for this session." },
+       { WERR_CTX_SERVICE_NAME_COLLISION, "A service with the same name already exists on the system." },
+       { WERR_CTX_CLOSE_PENDING, "A close operation is pending on the session." },
+       { WERR_CTX_NO_OUTBUF, "There are no free output buffers available." },
+       { WERR_CTX_MODEM_INF_NOT_FOUND, "The MODEM.INF file was not found." },
+       { WERR_CTX_INVALID_MODEMNAME, "The modem name was not found in the MODEM.INF file." },
+       { WERR_CTX_MODEM_RESPONSE_ERROR, "The modem did not accept the command sent to it. Verify that the configured modem name matches the attached modem." },
+       { WERR_CTX_MODEM_RESPONSE_TIMEOUT, "The modem did not respond to the command sent to it. Verify that the modem is properly cabled and turned on." },
+       { WERR_CTX_MODEM_RESPONSE_NO_CARRIER, "Carrier detect has failed or carrier has been dropped due to disconnect." },
+       { WERR_CTX_MODEM_RESPONSE_NO_DIALTONE, "Dial tone not detected within the required time. Verify that the phone cable is properly attached and functional." },
+       { WERR_CTX_MODEM_RESPONSE_BUSY, "Busy signal detected at remote site on callback." },
+       { WERR_CTX_MODEM_RESPONSE_VOICE, "Voice detected at remote site on callback." },
+       { WERR_CTX_TD_ERROR, "Transport driver error" },
+       { WERR_CTX_WINSTATION_NOT_FOUND, "The specified session cannot be found." },
+       { WERR_CTX_WINSTATION_ALREADY_EXISTS, "The specified session name is already in use." },
+       { WERR_CTX_WINSTATION_BUSY, "The requested operation cannot be completed because the terminal connection is currently busy processing a connect, disconnect, reset, or delete operation." },
+       { WERR_CTX_BAD_VIDEO_MODE, "An attempt has been made to connect to a session whose video mode is not supported by the current client." },
+       { WERR_CTX_GRAPHICS_INVALID, "The application attempted to enable DOS graphics mode. DOS graphics mode is not supported." },
+       { WERR_CTX_LOGON_DISABLED, "Your interactive logon privilege has been disabled. Contact your administrator." },
+       { WERR_CTX_NOT_CONSOLE, "The requested operation can be performed only on the system console. This is most often the result of a driver or system DLL requiring direct console access." },
+       { WERR_CTX_CLIENT_QUERY_TIMEOUT, "The client failed to respond to the server connect message." },
+       { WERR_CTX_CONSOLE_DISCONNECT, "Disconnecting the console session is not supported." },
+       { WERR_CTX_CONSOLE_CONNECT, "Reconnecting a disconnected session to the console is not supported." },
+       { WERR_CTX_SHADOW_DENIED, "The request to control another session remotely was denied." },
+       { WERR_CTX_WINSTATION_ACCESS_DENIED, "The requested session access is denied." },
+       { WERR_CTX_INVALID_WD, "The specified terminal connection driver is invalid." },
+       { WERR_CTX_SHADOW_INVALID, "The requested session cannot be controlled remotely. This may be because the session is disconnected or does not currently have a user logged on." },
+       { WERR_CTX_SHADOW_DISABLED, "The requested session is not configured to allow remote control." },
+       { WERR_CTX_CLIENT_LICENSE_IN_USE, "Your request to connect to this terminal server has been rejected. Your terminal server client license number is currently being used by another user. Call your system administrator to obtain a unique license number." },
+       { WERR_CTX_CLIENT_LICENSE_NOT_SET, "Your request to connect to this terminal server has been rejected. Your terminal server client license number has not been entered for this copy of the terminal server client. Contact your system administrator." },
+       { WERR_CTX_LICENSE_NOT_AVAILABLE, "The number of connections to this computer is limited and all connections are in use right now. Try connecting later or contact your system administrator." },
+       { WERR_CTX_LICENSE_CLIENT_INVALID, "The client you are using is not licensed to use this system. Your logon request is denied." },
+       { WERR_CTX_LICENSE_EXPIRED, "The system license has expired. Your logon request is denied." },
+       { WERR_CTX_SHADOW_NOT_RUNNING, "Remote control could not be terminated because the specified session is not currently being remotely controlled." },
+       { WERR_CTX_SHADOW_ENDED_BY_MODE_CHANGE, "The remote control of the console was terminated because the display mode was changed. Changing the display mode in a remote control session is not supported." },
+       { WERR_ACTIVATION_COUNT_EXCEEDED, "Activation has already been reset the maximum number of times for this installation. Your activation timer will not be cleared." },
+       { WERR_CTX_WINSTATIONS_DISABLED, "Remote logons are currently disabled." },
+       { WERR_CTX_ENCRYPTION_LEVEL_REQUIRED, "You do not have the proper encryption level to access this session." },
+       { WERR_CTX_SESSION_IN_USE, "The user %s\\%s is currently logged on to this computer. Only the current user or an administrator can log on to this computer." },
+       { WERR_CTX_NO_FORCE_LOGOFF, "The user %s\\%s is already logged on to the console of this computer. You do not have permission to log in at this time. To resolve this issue, contact %s\\%s and have them log off." },
+       { WERR_CTX_ACCOUNT_RESTRICTION, "Unable to log you on because of an account restriction." },
+       { WERR_RDP_PROTOCOL_ERROR, "The RDP component %2 detected an error in the protocol stream and has disconnected the client." },
+       { WERR_CTX_CDM_CONNECT, "The Client Drive Mapping Service has connected on terminal connection." },
+       { WERR_CTX_CDM_DISCONNECT, "The Client Drive Mapping Service has disconnected on terminal connection." },
+       { WERR_CTX_SECURITY_LAYER_ERROR, "The terminal server security layer detected an error in the protocol stream and has disconnected the client." },
+       { WERR_TS_INCOMPATIBLE_SESSIONS, "The target session is incompatible with the current session." },
+       { WERR_FRS_ERR_INVALID_API_SEQUENCE, "The file replication service API was called incorrectly." },
+       { WERR_FRS_ERR_STARTING_SERVICE, "The file replication service cannot be started." },
+       { WERR_FRS_ERR_STOPPING_SERVICE, "The file replication service cannot be stopped." },
+       { WERR_FRS_ERR_INTERNAL_API, "The file replication service API terminated the request. The event log may have more information." },
+       { WERR_FRS_ERR_INTERNAL, "The file replication service terminated the request. The event log may have more information." },
+       { WERR_FRS_ERR_SERVICE_COMM, "The file replication service cannot be contacted. The event log may have more information." },
+       { WERR_FRS_ERR_INSUFFICIENT_PRIV, "The file replication service cannot satisfy the request because the user has insufficient privileges. The event log may have more information." },
+       { WERR_FRS_ERR_AUTHENTICATION, "The file replication service cannot satisfy the request because authenticated RPC is not available. The event log may have more information." },
+       { WERR_FRS_ERR_PARENT_INSUFFICIENT_PRIV, "The file replication service cannot satisfy the request because the user has insufficient privileges on the domain controller. The event log may have more information." },
+       { WERR_FRS_ERR_PARENT_AUTHENTICATION, "The file replication service cannot satisfy the request because authenticated RPC is not available on the domain controller. The event log may have more information." },
+       { WERR_FRS_ERR_CHILD_TO_PARENT_COMM, "The file replication service cannot communicate with the file replication service on the domain controller. The event log may have more information." },
+       { WERR_FRS_ERR_PARENT_TO_CHILD_COMM, "The file replication service on the domain controller cannot communicate with the file replication service on this computer. The event log may have more information." },
+       { WERR_FRS_ERR_SYSVOL_POPULATE, "The file replication service cannot populate the system volume because of an internal error. The event log may have more information." },
+       { WERR_FRS_ERR_SYSVOL_POPULATE_TIMEOUT, "The file replication service cannot populate the system volume because of an internal time-out. The event log may have more information." },
+       { WERR_FRS_ERR_SYSVOL_IS_BUSY, "The file replication service cannot process the request. The system volume is busy with a previous request." },
+       { WERR_FRS_ERR_SYSVOL_DEMOTE, "The file replication service cannot stop replicating the system volume because of an internal error. The event log may have more information." },
+       { WERR_FRS_ERR_INVALID_SERVICE_PARAMETER, "The file replication service detected an invalid parameter." },
+       { WERR_DS_NOT_INSTALLED, "An error occurred while installing the directory service. For more information, see the event log." },
+       { WERR_DS_MEMBERSHIP_EVALUATED_LOCALLY, "The directory service evaluated group memberships locally." },
+       { WERR_DS_NO_ATTRIBUTE_OR_VALUE, "The specified directory service attribute or value does not exist." },
+       { WERR_DS_INVALID_ATTRIBUTE_YNTAX, "The attribute syntax specified to the directory service is invalid." },
+       { WERR_DS_ATTRIBUTE_TYPE_UNDEFINED, "The attribute type specified to the directory service is not defined." },
+       { WERR_DS_ATTRIBUTE_OR_VALUE_EXISTS, "The specified directory service attribute or value already exists." },
+       { WERR_DS_BUSY, "The directory service is busy." },
+       { WERR_DS_UNAVAILABLE, "The directory service is unavailable." },
+       { WERR_DS_NO_RIDS_ALLOCATED, "The directory service was unable to allocate a relative identifier." },
+       { WERR_DS_NO_MORE_RIDS, "The directory service has exhausted the pool of relative identifiers." },
+       { WERR_DS_INCORRECT_ROLE_OWNER, "The requested operation could not be performed because the directory service is not the master for that type of operation." },
+       { WERR_DS_RIDMGR_INIT_ERROR, "The directory service was unable to initialize the subsystem that allocates relative identifiers." },
+       { WERR_DS_OBJ_CLASS_VIOLATION, "The requested operation did not satisfy one or more constraints associated with the class of the object." },
+       { WERR_DS_CANT_ON_NON_LEAF, "The directory service can perform the requested operation only on a leaf object." },
+       { WERR_DS_CANT_ON_RDN, "The directory service cannot perform the requested operation on the relative distinguished name (RDN) attribute of an object." },
+       { WERR_DS_CANT_MOD_OBJ_CLASS, "The directory service detected an attempt to modify the object class of an object." },
+       { WERR_DS_CROSS_DOM_MOVE_ERROR, "The requested cross-domain move operation could not be performed." },
+       { WERR_DS_GC_NOT_AVAILABLE, "Unable to contact the global catalog (GC) server." },
+       { WERR_SHARED_POLICY, "The policy object is shared and can only be modified at the root." },
+       { WERR_POLICY_OBJECT_NOT_FOUND, "The policy object does not exist." },
+       { WERR_POLICY_ONLY_IN_DS, "The requested policy information is only in the directory service." },
+       { WERR_PROMOTION_ACTIVE, "A domain controller promotion is currently active." },
+       { WERR_NO_PROMOTION_ACTIVE, "A domain controller promotion is not currently active." },
+       { WERR_DS_OPERATIONS_ERROR, "An operations error occurred." },
+       { WERR_DS_PROTOCOL_ERROR, "A protocol error occurred." },
+       { WERR_DS_TIMELIMIT_EXCEEDED, "The time limit for this request was exceeded." },
+       { WERR_DS_SIZELIMIT_EXCEEDED, "The size limit for this request was exceeded." },
+       { WERR_DS_ADMIN_LIMIT_EXCEEDED, "The administrative limit for this request was exceeded." },
+       { WERR_DS_COMPARE_FALSE, "The compare response was false." },
+       { WERR_DS_COMPARE_TRUE, "The compare response was true." },
+       { WERR_DS_AUTH_METHOD_NOT_SUPPORTED, "The requested authentication method is not supported by the server." },
+       { WERR_DS_STRONG_AUTH_REQUIRED, "A more secure authentication method is required for this server." },
+       { WERR_DS_INAPPROPRIATE_AUTH, "Inappropriate authentication." },
+       { WERR_DS_AUTH_UNKNOWN, "The authentication mechanism is unknown." },
+       { WERR_DS_REFERRAL, "A referral was returned from the server." },
+       { WERR_DS_UNAVAILABLE_CRIT_EXTENSION, "The server does not support the requested critical extension." },
+       { WERR_DS_CONFIDENTIALITY_REQUIRED, "This request requires a secure connection." },
+       { WERR_DS_INAPPROPRIATE_MATCHING, "Inappropriate matching." },
+       { WERR_DS_CONSTRAINT_VIOLATION, "A constraint violation occurred." },
+       { WERR_DS_NO_SUCH_OBJECT, "There is no such object on the server." },
+       { WERR_DS_ALIAS_PROBLEM, "There is an alias problem." },
+       { WERR_DS_INVALID_DN_SYNTAX, "An invalid dn syntax has been specified." },
+       { WERR_DS_IS_LEAF, "The object is a leaf object." },
+       { WERR_DS_ALIAS_DEREF_PROBLEM, "There is an alias dereferencing problem." },
+       { WERR_DS_UNWILLING_TO_PERFORM, "The server is unwilling to process the request." },
+       { WERR_DS_LOOP_DETECT, "A loop has been detected." },
+       { WERR_DS_NAMING_VIOLATION, "There is a naming violation." },
+       { WERR_DS_OBJECT_RESULTS_TOO_LARGE, "The result set is too large." },
+       { WERR_DS_AFFECTS_MULTIPLE_DSAS, "The operation affects multiple DSAs." },
+       { WERR_DS_SERVER_DOWN, "The server is not operational." },
+       { WERR_DS_LOCAL_ERROR, "A local error has occurred." },
+       { WERR_DS_ENCODING_ERROR, "An encoding error has occurred." },
+       { WERR_DS_DECODING_ERROR, "A decoding error has occurred." },
+       { WERR_DS_FILTER_UNKNOWN, "The search filter cannot be recognized." },
+       { WERR_DS_PARAM_ERROR, "One or more parameters are illegal." },
+       { WERR_DS_NOT_SUPPORTED, "The specified method is not supported." },
+       { WERR_DS_NO_RESULTS_RETURNED, "No results were returned." },
+       { WERR_DS_CONTROL_NOT_FOUND, "The specified control is not supported by the server." },
+       { WERR_DS_CLIENT_LOOP, "A referral loop was detected by the client." },
+       { WERR_DS_REFERRAL_LIMIT_EXCEEDED, "The preset referral limit was exceeded." },
+       { WERR_DS_SORT_CONTROL_MISSING, "The search requires a SORT control." },
+       { WERR_DS_OFFSET_RANGE_ERROR, "The search results exceed the offset range specified." },
+       { WERR_DS_ROOT_MUST_BE_NC, "The root object must be the head of a naming context. The root object cannot have an instantiated parent." },
+       { WERR_DS_ADD_REPLICA_INHIBITED, "The add replica operation cannot be performed. The naming context must be writable to create the replica." },
+       { WERR_DS_ATT_NOT_DEF_IN_SCHEMA, "A reference to an attribute that is not defined in the schema occurred." },
+       { WERR_DS_MAX_OBJ_SIZE_EXCEEDED, "The maximum size of an object has been exceeded." },
+       { WERR_DS_OBJ_STRING_NAME_EXISTS, "An attempt was made to add an object to the directory with a name that is already in use." },
+       { WERR_DS_NO_RDN_DEFINED_IN_SCHEMA, "An attempt was made to add an object of a class that does not have an RDN defined in the schema." },
+       { WERR_DS_RDN_DOESNT_MATCH_SCHEMA, "An attempt was made to add an object using an RDN that is not the RDN defined in the schema." },
+       { WERR_DS_NO_REQUESTED_ATTS_FOUND, "None of the requested attributes were found on the objects." },
+       { WERR_DS_USER_BUFFER_TO_SMALL, "The user buffer is too small." },
+       { WERR_DS_ATT_IS_NOT_ON_OBJ, "The attribute specified in the operation is not present on the object." },
+       { WERR_DS_ILLEGAL_MOD_OPERATION, "Illegal modify operation. Some aspect of the modification is not permitted." },
+       { WERR_DS_OBJ_TOO_LARGE, "The specified object is too large." },
+       { WERR_DS_BAD_INSTANCE_TYPE, "The specified instance type is not valid." },
+       { WERR_DS_MASTERDSA_REQUIRED, "The operation must be performed at a master DSA." },
+       { WERR_DS_OBJECT_CLASS_REQUIRED, "The object class attribute must be specified." },
+       { WERR_DS_MISSING_REQUIRED_ATT, "A required attribute is missing." },
+       { WERR_DS_ATT_NOT_DEF_FOR_CLASS, "An attempt was made to modify an object to include an attribute that is not legal for its class." },
+       { WERR_DS_ATT_ALREADY_EXISTS, "The specified attribute is already present on the object." },
+       { WERR_DS_CANT_ADD_ATT_VALUES, "The specified attribute is not present, or has no values." },
+       { WERR_DS_SINGLE_VALUE_CONSTRAINT, "Multiple values were specified for an attribute that can have only one value." },
+       { WERR_DS_RANGE_CONSTRAINT, "A value for the attribute was not in the acceptable range of values." },
+       { WERR_DS_ATT_VAL_ALREADY_EXISTS, "The specified value already exists." },
+       { WERR_DS_CANT_REM_MISSING_ATT, "The attribute cannot be removed because it is not present on the object." },
+       { WERR_DS_CANT_REM_MISSING_ATT_VAL, "The attribute value cannot be removed because it is not present on the object." },
+       { WERR_DS_ROOT_CANT_BE_SUBREF, "The specified root object cannot be a subreference." },
+       { WERR_DS_NO_CHAINING, "Chaining is not permitted." },
+       { WERR_DS_NO_CHAINED_EVAL, "Chained evaluation is not permitted." },
+       { WERR_DS_NO_PARENT_OBJECT, "The operation could not be performed because the object\'s parent is either uninstantiated or deleted." },
+       { WERR_DS_PARENT_IS_AN_ALIAS, "Having a parent that is an alias is not permitted. Aliases are leaf objects." },
+       { WERR_DS_CANT_MIX_MASTER_AND_REPS, "The object and parent must be of the same type, either both masters or both replicas." },
+       { WERR_DS_CHILDREN_EXIST, "The operation cannot be performed because child objects exist. This operation can only be performed on a leaf object." },
+       { WERR_DS_OBJ_NOT_FOUND, "Directory object not found." },
+       { WERR_DS_ALIASED_OBJ_MISSING, "The aliased object is missing." },
+       { WERR_DS_BAD_NAME_SYNTAX, "The object name has bad syntax." },
+       { WERR_DS_ALIAS_POINTS_TO_ALIAS, "An alias is not permitted to refer to another alias." },
+       { WERR_DS_CANT_DEREF_ALIAS, "The alias cannot be dereferenced." },
+       { WERR_DS_OUT_OF_SCOPE, "The operation is out of scope." },
+       { WERR_DS_OBJECT_BEING_REMOVED, "The operation cannot continue because the object is in the process of being removed." },
+       { WERR_DS_CANT_DELETE_DSA_OBJ, "The DSA object cannot be deleted." },
+       { WERR_DS_GENERIC_ERROR, "A directory service error has occurred." },
+       { WERR_DS_DSA_MUST_BE_INT_MASTER, "The operation can only be performed on an internal master DSA object." },
+       { WERR_DS_CLASS_NOT_DSA, "The object must be of class DSA." },
+       { WERR_DS_INSUFF_ACCESS_RIGHTS, "Insufficient access rights to perform the operation." },
+       { WERR_DS_ILLEGAL_SUPERIOR, "The object cannot be added because the parent is not on the list of possible superiors." },
+       { WERR_DS_ATTRIBUTE_OWNED_BY_SAM, "Access to the attribute is not permitted because the attribute is owned by the SAM." },
+       { WERR_DS_NAME_TOO_MANY_PARTS, "The name has too many parts." },
+       { WERR_DS_NAME_TOO_LONG, "The name is too long." },
+       { WERR_DS_NAME_VALUE_TOO_LONG, "The name value is too long." },
+       { WERR_DS_NAME_UNPARSEABLE, "The directory service encountered an error parsing a name." },
+       { WERR_DS_NAME_TYPE_UNKNOWN, "The directory service cannot get the attribute type for a name." },
+       { WERR_DS_NOT_AN_OBJECT, "The name does not identify an object; the name identifies a phantom." },
+       { WERR_DS_SEC_DESC_TOO_SHORT, "The security descriptor is too short." },
+       { WERR_DS_SEC_DESC_INVALID, "The security descriptor is invalid." },
+       { WERR_DS_NO_DELETED_NAME, "Failed to create name for deleted object." },
+       { WERR_DS_SUBREF_MUST_HAVE_PARENT, "The parent of a new subreference must exist." },
+       { WERR_DS_NCNAME_MUST_BE_NC, "The object must be a naming context." },
+       { WERR_DS_CANT_ADD_SYSTEM_ONLY, "It is not permitted to add an attribute that is owned by the system." },
+       { WERR_DS_CLASS_MUST_BE_CONCRETE, "The class of the object must be structural; you cannot instantiate an abstract class." },
+       { WERR_DS_INVALID_DMD, "The schema object could not be found." },
+       { WERR_DS_OBJ_GUID_EXISTS, "A local object with this GUID (dead or alive) already exists." },
+       { WERR_DS_NOT_ON_BACKLINK, "The operation cannot be performed on a back link." },
+       { WERR_DS_NO_CROSSREF_FOR_NC, "The cross-reference for the specified naming context could not be found." },
+       { WERR_DS_SHUTTING_DOWN, "The operation could not be performed because the directory service is shutting down." },
+       { WERR_DS_UNKNOWN_OPERATION, "The directory service request is invalid." },
+       { WERR_DS_INVALID_ROLE_OWNER, "The role owner attribute could not be read." },
+       { WERR_DS_COULDNT_CONTACT_FSMO, "The requested Flexible Single Master Operations (FSMO) operation failed. The current FSMO holder could not be contacted." },
+       { WERR_DS_CROSS_NC_DN_RENAME, "Modification of a distinguished name across a naming context is not permitted." },
+       { WERR_DS_CANT_MOD_SYSTEM_ONLY, "The attribute cannot be modified because it is owned by the system." },
+       { WERR_DS_REPLICATOR_ONLY, "Only the replicator can perform this function." },
+       { WERR_DS_OBJ_CLASS_NOT_DEFINED, "The specified class is not defined." },
+       { WERR_DS_OBJ_CLASS_NOT_SUBCLASS, "The specified class is not a subclass." },
+       { WERR_DS_NAME_REFERENCE_INVALID, "The name reference is invalid." },
+       { WERR_DS_CROSS_REF_EXISTS, "A cross-reference already exists." },
+       { WERR_DS_CANT_DEL_MASTER_CROSSREF, "It is not permitted to delete a master cross-reference." },
+       { WERR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD, "Subtree notifications are only supported on naming context (NC) heads." },
+       { WERR_DS_NOTIFY_FILTER_TOO_COMPLEX, "Notification filter is too complex." },
+       { WERR_DS_DUP_RDN, "Schema update failed: Duplicate RDN." },
+       { WERR_DS_DUP_OID, "Schema update failed: Duplicate OID." },
+       { WERR_DS_DUP_MAPI_ID, "Schema update failed: Duplicate Message Application Programming Interface (MAPI) identifier." },
+       { WERR_DS_DUP_SCHEMA_ID_GUID, "Schema update failed: Duplicate schema ID GUID." },
+       { WERR_DS_DUP_LDAP_DISPLAY_NAME, "Schema update failed: Duplicate LDAP display name." },
+       { WERR_DS_SEMANTIC_ATT_TEST, "Schema update failed: Range-Lower less than Range-Upper." },
+       { WERR_DS_SYNTAX_MISMATCH, "Schema update failed: Syntax mismatch." },
+       { WERR_DS_EXISTS_IN_MUST_HAVE, "Schema deletion failed: Attribute is used in the Must-Contain list." },
+       { WERR_DS_EXISTS_IN_MAY_HAVE, "Schema deletion failed: Attribute is used in the May-Contain list." },
+       { WERR_DS_NONEXISTENT_MAY_HAVE, "Schema update failed: Attribute in May-Contain list does not exist." },
+       { WERR_DS_NONEXISTENT_MUST_HAVE, "Schema update failed: Attribute in the Must-Contain list does not exist." },
+       { WERR_DS_AUX_CLS_TEST_FAIL, "Schema update failed: Class in the Aux Class list does not exist or is not an auxiliary class." },
+       { WERR_DS_NONEXISTENT_POSS_SUP, "Schema update failed: Class in the Poss-Superiors list does not exist." },
+       { WERR_DS_SUB_CLS_TEST_FAIL, "Schema update failed: Class in the subclass of the list does not exist or does not satisfy hierarchy rules." },
+       { WERR_DS_BAD_RDN_ATT_ID_SYNTAX, "Schema update failed: Rdn-Att-Id has wrong syntax." },
+       { WERR_DS_EXISTS_IN_AUX_CLS, "Schema deletion failed: Class is used as an auxiliary class." },
+       { WERR_DS_EXISTS_IN_SUB_CLS, "Schema deletion failed: Class is used as a subclass." },
+       { WERR_DS_EXISTS_IN_POSS_SUP, "Schema deletion failed: Class is used as a Poss-Superior." },
+       { WERR_DS_RECALCSCHEMA_FAILED, "Schema update failed in recalculating validation cache." },
+       { WERR_DS_TREE_DELETE_NOT_FINISHED, "The tree deletion is not finished. The request must be made again to continue deleting the tree." },
+       { WERR_DS_CANT_DELETE, "The requested delete operation could not be performed." },
+       { WERR_DS_ATT_SCHEMA_REQ_ID, "Cannot read the governs class identifier for the schema record." },
+       { WERR_DS_BAD_ATT_SCHEMA_SYNTAX, "The attribute schema has bad syntax." },
+       { WERR_DS_CANT_CACHE_ATT, "The attribute could not be cached." },
+       { WERR_DS_CANT_CACHE_CLASS, "The class could not be cached." },
+       { WERR_DS_CANT_REMOVE_ATT_CACHE, "The attribute could not be removed from the cache." },
+       { WERR_DS_CANT_REMOVE_CLASS_CACHE, "The class could not be removed from the cache." },
+       { WERR_DS_CANT_RETRIEVE_DN, "The distinguished name attribute could not be read." },
+       { WERR_DS_MISSING_SUPREF, "No superior reference has been configured for the directory service. The directory service is, therefore, unable to issue referrals to objects outside this forest." },
+       { WERR_DS_CANT_RETRIEVE_INSTANCE, "The instance type attribute could not be retrieved." },
+       { WERR_DS_CODE_INCONSISTENCY, "An internal error has occurred." },
+       { WERR_DS_DATABASE_ERROR, "A database error has occurred." },
+       { WERR_DS_MISSING_EXPECTED_ATT, "An expected attribute is missing." },
+       { WERR_DS_NCNAME_MISSING_CR_REF, "The specified naming context is missing a cross-reference." },
+       { WERR_DS_SECURITY_CHECKING_ERROR, "A security checking error has occurred." },
+       { WERR_DS_SCHEMA_NOT_LOADED, "The schema is not loaded." },
+       { WERR_DS_SCHEMA_ALLOC_FAILED, "Schema allocation failed. Check if the machine is running low on memory." },
+       { WERR_DS_ATT_SCHEMA_REQ_SYNTAX, "Failed to obtain the required syntax for the attribute schema." },
+       { WERR_DS_GCVERIFY_ERROR, "The GC verification failed. The GC is not available or does not support the operation. Some part of the directory is currently not available." },
+       { WERR_DS_DRA_SCHEMA_MISMATCH, "The replication operation failed because of a schema mismatch between the servers involved." },
+       { WERR_DS_CANT_FIND_DSA_OBJ, "The DSA object could not be found." },
+       { WERR_DS_CANT_FIND_EXPECTED_NC, "The naming context could not be found." },
+       { WERR_DS_CANT_FIND_NC_IN_CACHE, "The naming context could not be found in the cache." },
+       { WERR_DS_CANT_RETRIEVE_CHILD, "The child object could not be retrieved." },
+       { WERR_DS_SECURITY_ILLEGAL_MODIFY, "The modification was not permitted for security reasons." },
+       { WERR_DS_CANT_REPLACE_HIDDEN_REC, "The operation cannot replace the hidden record." },
+       { WERR_DS_BAD_HIERARCHY_FILE, "The hierarchy file is invalid." },
+       { WERR_DS_BUILD_HIERARCHY_TABLE_FAILED, "The attempt to build the hierarchy table failed." },
+       { WERR_DS_CONFIG_PARAM_MISSING, "The directory configuration parameter is missing from the registry." },
+       { WERR_DS_COUNTING_AB_INDICES_FAILED, "The attempt to count the address book indices failed." },
+       { WERR_DS_HIERARCHY_TABLE_MALLOC_FAILED, "The allocation of the hierarchy table failed." },
+       { WERR_DS_INTERNAL_FAILURE, "The directory service encountered an internal failure." },
+       { WERR_DS_UNKNOWN_ERROR, "The directory service encountered an unknown failure." },
+       { WERR_DS_ROOT_REQUIRES_CLASS_TOP, "A root object requires a class of \"top\"." },
+       { WERR_DS_REFUSING_FSMO_ROLES, "This directory server is shutting down, and cannot take ownership of new floating single-master operation roles." },
+       { WERR_DS_MISSING_FSMO_SETTINGS, "The directory service is missing mandatory configuration information and is unable to determine the ownership of floating single-master operation roles." },
+       { WERR_DS_UNABLE_TO_SURRENDER_ROLES, "The directory service was unable to transfer ownership of one or more floating single-master operation roles to other servers." },
+       { WERR_DS_DRA_GENERIC, "The replication operation failed." },
+       { WERR_DS_DRA_INVALID_PARAMETER, "An invalid parameter was specified for this replication operation." },
+       { WERR_DS_DRA_BUSY, "The directory service is too busy to complete the replication operation at this time." },
+       { WERR_DS_DRA_BAD_DN, "The DN specified for this replication operation is invalid." },
+       { WERR_DS_DRA_BAD_NC, "The naming context specified for this replication operation is invalid." },
+       { WERR_DS_DRA_DN_EXISTS, "The DN specified for this replication operation already exists." },
+       { WERR_DS_DRA_INTERNAL_ERROR, "The replication system encountered an internal error." },
+       { WERR_DS_DRA_INCONSISTENT_DIT, "The replication operation encountered a database inconsistency." },
+       { WERR_DS_DRA_CONNECTION_FAILED, "The server specified for this replication operation could not be contacted." },
+       { WERR_DS_DRA_BAD_INSTANCE_TYPE, "The replication operation encountered an object with an invalid instance type." },
+       { WERR_DS_DRA_OUT_OF_MEM, "The replication operation failed to allocate memory." },
+       { WERR_DS_DRA_MAIL_PROBLEM, "The replication operation encountered an error with the mail system." },
+       { WERR_DS_DRA_REF_ALREADY_EXISTS, "The replication reference information for the target server already exists." },
+       { WERR_DS_DRA_REF_NOT_FOUND, "The replication reference information for the target server does not exist." },
+       { WERR_DS_DRA_OBJ_IS_REP_SOURCE, "The naming context cannot be removed because it is replicated to another server." },
+       { WERR_DS_DRA_DB_ERROR, "The replication operation encountered a database error." },
+       { WERR_DS_DRA_NO_REPLICA, "The naming context is in the process of being removed or is not replicated from the specified server." },
+       { WERR_DS_DRA_ACCESS_DENIED, "Replication access was denied." },
+       { WERR_DS_DRA_NOT_SUPPORTED, "The requested operation is not supported by this version of the directory service." },
+       { WERR_DS_DRA_RPC_CANCELLED, "The replication RPC was canceled." },
+       { WERR_DS_DRA_SOURCE_DISABLED, "The source server is currently rejecting replication requests." },
+       { WERR_DS_DRA_SINK_DISABLED, "The destination server is currently rejecting replication requests." },
+       { WERR_DS_DRA_NAME_COLLISION, "The replication operation failed due to a collision of object names." },
+       { WERR_DS_DRA_SOURCE_REINSTALLED, "The replication source has been reinstalled." },
+       { WERR_DS_DRA_MISSING_PARENT, "The replication operation failed because a required parent object is missing." },
+       { WERR_DS_DRA_PREEMPTED, "The replication operation was preempted." },
+       { WERR_DS_DRA_ABANDON_SYNC, "The replication synchronization attempt was abandoned because of a lack of updates." },
+       { WERR_DS_DRA_SHUTDOWN, "The replication operation was terminated because the system is shutting down." },
+       { WERR_DS_DRA_INCOMPATIBLE_PARTIAL_SET, "A synchronization attempt failed because the destination DC is currently waiting to synchronize new partial attributes from the source. This condition is normal if a recent schema change modified the partial attribute set. The destination partial attribute set is not a subset of the source partial attribute set." },
+       { WERR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA, "The replication synchronization attempt failed because a master replica attempted to sync from a partial replica." },
+       { WERR_DS_DRA_EXTN_CONNECTION_FAILED, "The server specified for this replication operation was contacted, but that server was unable to contact an additional server needed to complete the operation." },
+       { WERR_DS_INSTALL_SCHEMA_MISMATCH, "The version of the directory service schema of the source forest is not compatible with the version of the directory service on this computer." },
+       { WERR_DS_DUP_LINK_ID, "Schema update failed: An attribute with the same link identifier already exists." },
+       { WERR_DS_NAME_ERROR_RESOLVING, "Name translation: Generic processing error." },
+       { WERR_DS_NAME_ERROR_NOT_FOUND, "Name translation: Could not find the name or insufficient right to see name." },
+       { WERR_DS_NAME_ERROR_NOT_UNIQUE, "Name translation: Input name mapped to more than one output name." },
+       { WERR_DS_NAME_ERROR_NO_MAPPING, "Name translation: The input name was found but not the associated output format." },
+       { WERR_DS_NAME_ERROR_DOMAIN_ONLY, "Name translation: Unable to resolve completely, only the domain was found." },
+       { WERR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING, "Name translation: Unable to perform purely syntactical mapping at the client without going out to the wire." },
+       { WERR_DS_CONSTRUCTED_ATT_MOD, "Modification of a constructed attribute is not allowed." },
+       { WERR_DS_WRONG_OM_OBJ_CLASS, "The OM-Object-Class specified is incorrect for an attribute with the specified syntax." },
+       { WERR_DS_DRA_REPL_PENDING, "The replication request has been posted; waiting for a reply." },
+       { WERR_DS_DS_REQUIRED, "The requested operation requires a directory service, and none was available." },
+       { WERR_DS_INVALID_LDAP_DISPLAY_NAME, "The LDAP display name of the class or attribute contains non-ASCII characters." },
+       { WERR_DS_NON_BASE_SEARCH, "The requested search operation is only supported for base searches." },
+       { WERR_DS_CANT_RETRIEVE_ATTS, "The search failed to retrieve attributes from the database." },
+       { WERR_DS_BACKLINK_WITHOUT_LINK, "The schema update operation tried to add a backward link attribute that has no corresponding forward link." },
+       { WERR_DS_EPOCH_MISMATCH, "The source and destination of a cross-domain move do not agree on the object\'s epoch number. Either the source or the destination does not have the latest version of the object." },
+       { WERR_DS_SRC_NAME_MISMATCH, "The source and destination of a cross-domain move do not agree on the object\'s current name. Either the source or the destination does not have the latest version of the object." },
+       { WERR_DS_SRC_AND_DST_NC_IDENTICAL, "The source and destination for the cross-domain move operation are identical. The caller should use a local move operation instead of a cross-domain move operation." },
+       { WERR_DS_DST_NC_MISMATCH, "The source and destination for a cross-domain move do not agree on the naming contexts in the forest. Either the source or the destination does not have the latest version of the Partitions container." },
+       { WERR_DS_NOT_AUTHORITIVE_FOR_DST_NC, "The destination of a cross-domain move is not authoritative for the destination naming context." },
+       { WERR_DS_SRC_GUID_MISMATCH, "The source and destination of a cross-domain move do not agree on the identity of the source object. Either the source or the destination does not have the latest version of the source object." },
+       { WERR_DS_CANT_MOVE_DELETED_OBJECT, "The object being moved across domains is already known to be deleted by the destination server. The source server does not have the latest version of the source object." },
+       { WERR_DS_PDC_OPERATION_IN_PROGRESS, "Another operation that requires exclusive access to the PDC FSMO is already in progress." },
+       { WERR_DS_CROSS_DOMAIN_CLEANUP_REQD, "A cross-domain move operation failed because two versions of the moved object exist—one each in the source and destination domains. The destination object needs to be removed to restore the system to a consistent state." },
+       { WERR_DS_ILLEGAL_XDOM_MOVE_OPERATION, "This object may not be moved across domain boundaries either because cross-domain moves for this class are not allowed, or the object has some special characteristics, for example, a trust account or a restricted relative identifier (RID), that prevent its move." },
+       { WERR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS, "Cannot move objects with memberships across domain boundaries because, once moved, this violates the membership conditions of the account group. Remove the object from any account group memberships and retry." },
+       { WERR_DS_NC_MUST_HAVE_NC_PARENT, "A naming context head must be the immediate child of another naming context head, not of an interior node." },
+       { WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE, "The directory cannot validate the proposed naming context name because it does not hold a replica of the naming context above the proposed naming context. Ensure that the domain naming master role is held by a server that is configured as a GC server, and that the server is up-to-date with its replication partners. (Applies only to Windows 2000 domain naming masters.)" },
+       { WERR_DS_DST_DOMAIN_NOT_NATIVE, "Destination domain must be in native mode." },
+       { WERR_DS_MISSING_INFRASTRUCTURE_CONTAINER, "The operation cannot be performed because the server does not have an infrastructure container in the domain of interest." },
+       { WERR_DS_CANT_MOVE_ACCOUNT_GROUP, "Cross-domain moves of nonempty account groups is not allowed." },
+       { WERR_DS_CANT_MOVE_RESOURCE_GROUP, "Cross-domain moves of nonempty resource groups is not allowed." },
+       { WERR_DS_INVALID_SEARCH_FLAG, "The search flags for the attribute are invalid. The ambiguous name resolution (ANR) bit is valid only on attributes of Unicode or Teletex strings." },
+       { WERR_DS_NO_TREE_DELETE_ABOVE_NC, "Tree deletions starting at an object that has an NC head as a descendant are not allowed." },
+       { WERR_DS_COULDNT_LOCK_TREE_FOR_DELETE, "The directory service failed to lock a tree in preparation for a tree deletion because the tree was in use." },
+       { WERR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE, "The directory service failed to identify the list of objects to delete while attempting a tree deletion." },
+       { WERR_DS_SAM_INIT_FAILURE, "SAM initialization failed because of the following error: %1. Error Status: 0x%2. Click OK to shut down the system and reboot into Directory Services Restore Mode. Check the event log for detailed information." },
+       { WERR_DS_SENSITIVE_GROUP_VIOLATION, "Only an administrator can modify the membership list of an administrative group." },
+       { WERR_DS_CANT_MOD_PRIMARYGROUPID, "Cannot change the primary group ID of a domain controller account." },
+       { WERR_DS_ILLEGAL_BASE_SCHEMA_MOD, "An attempt was made to modify the base schema." },
+       { WERR_DS_NONSAFE_SCHEMA_CHANGE, "Adding a new mandatory attribute to an existing class, deleting a mandatory attribute from an existing class, or adding an optional attribute to the special class Top that is not a backlink attribute (directly or through inheritance, for example, by adding or deleting an auxiliary class) is not allowed." },
+       { WERR_DS_SCHEMA_UPDATE_DISALLOWED, "Schema update is not allowed on this DC because the DC is not the schema FSMO role owner." },
+       { WERR_DS_CANT_CREATE_UNDER_SCHEMA, "An object of this class cannot be created under the schema container. You can only create Attribute-Schema and Class-Schema objects under the schema container." },
+       { WERR_DS_INVALID_GROUP_TYPE, "The specified group type is invalid." },
+       { WERR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, "You cannot nest global groups in a mixed domain if the group is security-enabled." },
+       { WERR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, "You cannot nest local groups in a mixed domain if the group is security-enabled." },
+       { WERR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, "A global group cannot have a local group as a member." },
+       { WERR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, "A global group cannot have a universal group as a member." },
+       { WERR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, "A universal group cannot have a local group as a member." },
+       { WERR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, "A global group cannot have a cross-domain member." },
+       { WERR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, "A local group cannot have another cross domain local group as a member." },
+       { WERR_DS_HAVE_PRIMARY_MEMBERS, "A group with primary members cannot change to a security-disabled group." },
+       { WERR_DS_STRING_SD_CONVERSION_FAILED, "The schema cache load failed to convert the string default security descriptor (SD) on a class-schema object." },
+       { WERR_DS_NAMING_MASTER_GC, "Only DSAs configured to be GC servers should be allowed to hold the domain naming master FSMO role. (Applies only to Windows 2000 servers.)" },
+       { WERR_DS_DNS_LOOKUP_FAILURE, "The DSA operation is unable to proceed because of a DNS lookup failure." },
+       { WERR_DS_COULDNT_UPDATE_SPNS, "While processing a change to the DNS host name for an object, the SPN values could not be kept in sync." },
+       { WERR_DS_CANT_RETRIEVE_SD, "The Security Descriptor attribute could not be read." },
+       { WERR_DS_KEY_NOT_UNIQUE, "The object requested was not found, but an object with that key was found." },
+       { WERR_DS_WRONG_LINKED_ATT_SYNTAX, "The syntax of the linked attribute being added is incorrect. Forward links can only have syntax 2.5.5.1, 2.5.5.7, and 2.5.5.14, and backlinks can only have syntax 2.5.5.1." },
+       { WERR_DS_SAM_NEED_BOOTKEY_PASSWORD, "SAM needs to get the boot password." },
+       { WERR_DS_SAM_NEED_BOOTKEY_FLOPPY, "SAM needs to get the boot key from the floppy disk." },
+       { WERR_DS_CANT_START, "Directory Service cannot start." },
+       { WERR_DS_INIT_FAILURE, "Directory Services could not start." },
+       { WERR_DS_NO_PKT_PRIVACY_ON_CONNECTION, "The connection between client and server requires packet privacy or better." },
+       { WERR_DS_SOURCE_DOMAIN_IN_FOREST, "The source domain may not be in the same forest as the destination." },
+       { WERR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST, "The destination domain must be in the forest." },
+       { WERR_DS_DESTINATION_AUDITING_NOT_ENABLED, "The operation requires that destination domain auditing be enabled." },
+       { WERR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN, "The operation could not locate a DC for the source domain." },
+       { WERR_DS_SRC_OBJ_NOT_GROUP_OR_USER, "The source object must be a group or user." },
+       { WERR_DS_SRC_SID_EXISTS_IN_FOREST, "The source object\'s SID already exists in the destination forest." },
+       { WERR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH, "The source and destination object must be of the same type." },
+       { WERR_SAM_INIT_FAILURE, "SAM initialization failed because of the following error: %1. Error Status: 0x%2. Click OK to shut down the system and reboot into Safe Mode. Check the event log for detailed information." },
+       { WERR_DS_DRA_SCHEMA_INFO_SHIP, "Schema information could not be included in the replication request." },
+       { WERR_DS_DRA_SCHEMA_CONFLICT, "The replication operation could not be completed due to a schema incompatibility." },
+       { WERR_DS_DRA_EARLIER_SCHEMA_CONFLICT, "The replication operation could not be completed due to a previous schema incompatibility." },
+       { WERR_DS_DRA_OBJ_NC_MISMATCH, "The replication update could not be applied because either the source or the destination has not yet received information regarding a recent cross-domain move operation." },
+       { WERR_DS_NC_STILL_HAS_DSAS, "The requested domain could not be deleted because there exist domain controllers that still host this domain." },
+       { WERR_DS_GC_REQUIRED, "The requested operation can be performed only on a GC server." },
+       { WERR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, "A local group can only be a member of other local groups in the same domain." },
+       { WERR_DS_NO_FPO_IN_UNIVERSAL_GROUPS, "Foreign security principals cannot be members of universal groups." },
+       { WERR_DS_CANT_ADD_TO_GC, "The attribute is not allowed to be replicated to the GC because of security reasons." },
+       { WERR_DS_NO_CHECKPOINT_WITH_PDC, "The checkpoint with the PDC could not be taken because too many modifications are currently being processed." },
+       { WERR_DS_SOURCE_AUDITING_NOT_ENABLED, "The operation requires that source domain auditing be enabled." },
+       { WERR_DS_CANT_CREATE_IN_NONDOMAIN_NC, "Security principal objects can only be created inside domain naming contexts." },
+       { WERR_DS_INVALID_NAME_FOR_SPN, "An SPN could not be constructed because the provided host name is not in the necessary format." },
+       { WERR_DS_FILTER_USES_CONTRUCTED_ATTRS, "A filter was passed that uses constructed attributes." },
+       { WERR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED, "Your computer could not be joined to the domain. You have exceeded the maximum number of computer accounts you are allowed to create in this domain. Contact your system administrator to have this limit reset or increased." },
+       { WERR_DS_MUST_BE_RUN_ON_DST_DC, "For security reasons, the operation must be run on the destination DC." },
+       { WERR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER, "For security reasons, the source DC must be Windows NT 4.0 SP4 and later." },
+       { WERR_DS_CANT_TREE_DELETE_CRITICAL_OBJ, "Critical directory service system objects cannot be deleted during tree deletion operations. The tree deletion may have been partially performed." },
+       { WERR_DS_INIT_FAILURE_CONSOLE, "Directory Services could not start because of the following error: %1. Error Status: 0x%2. Click OK to shut down the system. You can use the Recovery Console to further diagnose the system." },
+       { WERR_DS_SAM_INIT_FAILURE_CONSOLE, "SAM initialization failed because of the following error: %1. Error Status: 0x%2. Click OK to shut down the system. You can use the Recovery Console to further diagnose the system." },
+       { WERR_DS_FOREST_VERSION_TOO_HIGH, "The version of the operating system installed is incompatible with the current forest functional level. You must upgrade to a new version of the operating system before this server can become a domain controller in this forest." },
+       { WERR_DS_DOMAIN_VERSION_TOO_HIGH, "The version of the operating system installed is incompatible with the current domain functional level. You must upgrade to a new version of the operating system before this server can become a domain controller in this domain." },
+       { WERR_DS_FOREST_VERSION_TOO_LOW, "The version of the operating system installed on this server no longer supports the current forest functional level. You must raise the forest functional level before this server can become a domain controller in this forest." },
+       { WERR_DS_DOMAIN_VERSION_TOO_LOW, "The version of the operating system installed on this server no longer supports the current domain functional level. You must raise the domain functional level before this server can become a domain controller in this domain." },
+       { WERR_DS_INCOMPATIBLE_VERSION, "The version of the operating system installed on this server is incompatible with the functional level of the domain or forest." },
+       { WERR_DS_LOW_DSA_VERSION, "The functional level of the domain (or forest) cannot be raised to the requested value because one or more domain controllers in the domain (or forest) are at a lower, incompatible functional level." },
+       { WERR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN, "The forest functional level cannot be raised to the requested value because one or more domains are still in mixed-domain mode. All domains in the forest must be in native mode for you to raise the forest functional level." },
+       { WERR_DS_NOT_SUPPORTED_SORT_ORDER, "The sort order requested is not supported." },
+       { WERR_DS_NAME_NOT_UNIQUE, "The requested name already exists as a unique identifier." },
+       { WERR_DS_MACHINE_ACCOUNT_CREATED_PRENT4, "The machine account was created before Windows NT 4.0. The account needs to be re-created." },
+       { WERR_DS_OUT_OF_VERSION_STORE, "The database is out of version store." },
+       { WERR_DS_INCOMPATIBLE_CONTROLS_USED, "Unable to continue operation because multiple conflicting controls were used." },
+       { WERR_DS_NO_REF_DOMAIN, "Unable to find a valid security descriptor reference domain for this partition." },
+       { WERR_DS_RESERVED_LINK_ID, "Schema update failed: The link identifier is reserved." },
+       { WERR_DS_LINK_ID_NOT_AVAILABLE, "Schema update failed: There are no link identifiers available." },
+       { WERR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER, "An account group cannot have a universal group as a member." },
+       { WERR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE, "Rename or move operations on naming context heads or read-only objects are not allowed." },
+       { WERR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC, "Move operations on objects in the schema naming context are not allowed." },
+       { WERR_DS_MODIFYDN_DISALLOWED_BY_FLAG, "A system flag has been set on the object that does not allow the object to be moved or renamed." },
+       { WERR_DS_MODIFYDN_WRONG_GRANDPARENT, "This object is not allowed to change its grandparent container. Moves are not forbidden on this object, but are restricted to sibling containers." },
+       { WERR_DS_NAME_ERROR_TRUST_REFERRAL, "Unable to resolve completely; a referral to another forest was generated." },
+       { WERR_NOT_SUPPORTED_ON_STANDARD_SERVER, "The requested action is not supported on a standard server." },
+       { WERR_DS_CANT_ACCESS_REMOTE_PART_OF_AD, "Could not access a partition of the directory service located on a remote server. Make sure at least one server is running for the partition in question." },
+       { WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2, "The directory cannot validate the proposed naming context (or partition) name because it does not hold a replica, nor can it contact a replica of the naming context above the proposed naming context. Ensure that the parent naming context is properly registered in the DNS, and at least one replica of this naming context is reachable by the domain naming master." },
+       { WERR_DS_THREAD_LIMIT_EXCEEDED, "The thread limit for this request was exceeded." },
+       { WERR_DS_NOT_CLOSEST, "The GC server is not in the closest site." },
+       { WERR_DS_SINGLE_USER_MODE_FAILED, "The directory service failed to enter single-user mode." },
+       { WERR_DS_NTDSCRIPT_SYNTAX_ERROR, "The directory service cannot parse the script because of a syntax error." },
+       { WERR_DS_NTDSCRIPT_PROCESS_ERROR, "The directory service cannot process the script because of an error." },
+       { WERR_DS_DIFFERENT_REPL_EPOCHS, "The directory service cannot perform the requested operation because the servers involved are of different replication epochs (which is usually related to a domain rename that is in progress)." },
+       { WERR_DS_DRS_EXTENSIONS_CHANGED, "The directory service binding must be renegotiated due to a change in the server extensions information." },
+       { WERR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR, "The operation is not allowed on a disabled cross-reference." },
+       { WERR_DS_NO_MSDS_INTID, "Schema update failed: No values for msDS-IntId are available." },
+       { WERR_DS_DUP_MSDS_INTID, "Schema update failed: Duplicate msDS-IntId. Retry the operation." },
+       { WERR_DS_EXISTS_IN_RDNATTID, "Schema deletion failed: Attribute is used in rDNAttID." },
+       { WERR_DS_AUTHORIZATION_FAILED, "The directory service failed to authorize the request." },
+       { WERR_DS_INVALID_SCRIPT, "The directory service cannot process the script because it is invalid." },
+       { WERR_DS_REMOTE_CROSSREF_OP_FAILED, "The remote create cross-reference operation failed on the domain naming master FSMO. The operation\'s error is in the extended data." },
+       { WERR_DS_CROSS_REF_BUSY, "A cross-reference is in use locally with the same name." },
+       { WERR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN, "The directory service cannot derive an SPN with which to mutually authenticate the target server because the server\'s domain has been deleted from the forest." },
+       { WERR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC, "Writable NCs prevent this DC from demoting." },
+       { WERR_DS_DUPLICATE_ID_FOUND, "The requested object has a nonunique identifier and cannot be retrieved." },
+       { WERR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT, "Insufficient attributes were given to create an object. This object may not exist because it may have been deleted and the garbage already collected." },
+       { WERR_DS_GROUP_CONVERSION_ERROR, "The group cannot be converted due to attribute restrictions on the requested group type." },
+       { WERR_DS_CANT_MOVE_APP_BASIC_GROUP, "Cross-domain moves of nonempty basic application groups is not allowed." },
+       { WERR_DS_CANT_MOVE_APP_QUERY_GROUP, "Cross-domain moves of nonempty query-based application groups is not allowed." },
+       { WERR_DS_ROLE_NOT_VERIFIED, "The FSMO role ownership could not be verified because its directory partition did not replicate successfully with at least one replication partner." },
+       { WERR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL, "The target container for a redirection of a well-known object container cannot already be a special container." },
+       { WERR_DS_DOMAIN_RENAME_IN_PROGRESS, "The directory service cannot perform the requested operation because a domain rename operation is in progress." },
+       { WERR_DS_EXISTING_AD_CHILD_NC, "The directory service detected a child partition below the requested partition name. The partition hierarchy must be created in a top down method." },
+       { WERR_DS_REPL_LIFETIME_EXCEEDED, "The directory service cannot replicate with this server because the time since the last replication with this server has exceeded the tombstone lifetime." },
+       { WERR_DS_DISALLOWED_IN_SYSTEM_CONTAINER, "The requested operation is not allowed on an object under the system container." },
+       { WERR_DS_LDAP_SEND_QUEUE_FULL, "The LDAP server\'s network send queue has filled up because the client is not processing the results of its requests fast enough. No more requests will be processed until the client catches up. If the client does not catch up then it will be disconnected." },
+       { WERR_DS_DRA_OUT_SCHEDULE_WINDOW, "The scheduled replication did not take place because the system was too busy to execute the request within the schedule window. The replication queue is overloaded. Consider reducing the number of partners or decreasing the scheduled replication frequency." },
+       { WERR_DS_POLICY_NOT_KNOWN, "At this time, it cannot be determined if the branch replication policy is available on the hub domain controller. Retry at a later time to account for replication latencies." },
+       { WERR_NO_SITE_SETTINGS_OBJECT, "The site settings object for the specified site does not exist." },
+       { WERR_NO_SECRETS, "The local account store does not contain secret material for the specified account." },
+       { WERR_NO_WRITABLE_DC_FOUND, "Could not find a writable domain controller in the domain." },
+       { WERR_DS_NO_SERVER_OBJECT, "The server object for the domain controller does not exist." },
+       { WERR_DS_NO_NTDSA_OBJECT, "The NTDS Settings object for the domain controller does not exist." },
+       { WERR_DS_NON_ASQ_SEARCH, "The requested search operation is not supported for attribute scoped query (ASQ) searches." },
+       { WERR_DS_AUDIT_FAILURE, "A required audit event could not be generated for the operation." },
+       { WERR_DS_INVALID_SEARCH_FLAG_SUBTREE, "The search flags for the attribute are invalid. The subtree index bit is valid only on single-valued attributes." },
+       { WERR_DS_INVALID_SEARCH_FLAG_TUPLE, "The search flags for the attribute are invalid. The tuple index bit is valid only on attributes of Unicode strings." },
+       { WERR_IPSEC_QM_POLICY_EXISTS, "The specified quick mode policy already exists." },
+       { WERR_IPSEC_QM_POLICY_NOT_FOUND, "The specified quick mode policy was not found." },
+       { WERR_IPSEC_QM_POLICY_IN_USE, "The specified quick mode policy is being used." },
+       { WERR_IPSEC_MM_POLICY_EXISTS, "The specified main mode policy already exists." },
+       { WERR_IPSEC_MM_POLICY_NOT_FOUND, "The specified main mode policy was not found." },
+       { WERR_IPSEC_MM_POLICY_IN_USE, "The specified main mode policy is being used." },
+       { WERR_IPSEC_MM_FILTER_EXISTS, "The specified main mode filter already exists." },
+       { WERR_IPSEC_MM_FILTER_NOT_FOUND, "The specified main mode filter was not found." },
+       { WERR_IPSEC_TRANSPORT_FILTER_EXISTS, "The specified transport mode filter already exists." },
+       { WERR_IPSEC_TRANSPORT_FILTER_NOT_FOUND, "The specified transport mode filter does not exist." },
+       { WERR_IPSEC_MM_AUTH_EXISTS, "The specified main mode authentication list exists." },
+       { WERR_IPSEC_MM_AUTH_NOT_FOUND, "The specified main mode authentication list was not found." },
+       { WERR_IPSEC_MM_AUTH_IN_USE, "The specified main mode authentication list is being used." },
+       { WERR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND, "The specified default main mode policy was not found." },
+       { WERR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND, "The specified default main mode authentication list was not found." },
+       { WERR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND, "The specified default quick mode policy was not found." },
+       { WERR_IPSEC_TUNNEL_FILTER_EXISTS, "The specified tunnel mode filter exists." },
+       { WERR_IPSEC_TUNNEL_FILTER_NOT_FOUND, "The specified tunnel mode filter was not found." },
+       { WERR_IPSEC_MM_FILTER_PENDING_DELETION, "The main mode filter is pending deletion." },
+       { WERR_IPSEC_TRANSPORT_FILTER_ENDING_DELETION, "The transport filter is pending deletion." },
+       { WERR_IPSEC_TUNNEL_FILTER_PENDING_DELETION, "The tunnel filter is pending deletion." },
+       { WERR_IPSEC_MM_POLICY_PENDING_ELETION, "The main mode policy is pending deletion." },
+       { WERR_IPSEC_MM_AUTH_PENDING_DELETION, "The main mode authentication bundle is pending deletion." },
+       { WERR_IPSEC_QM_POLICY_PENDING_DELETION, "The quick mode policy is pending deletion." },
+       { WERR_IPSEC_IKE_NEG_STATUS_BEGIN, "ERROR_IPSEC_IKE_NEG_STATUS_BEGIN" },
+       { WERR_IPSEC_IKE_AUTH_FAIL, "The IKE authentication credentials are unacceptable." },
+       { WERR_IPSEC_IKE_ATTRIB_FAIL, "The IKE security attributes are unacceptable." },
+       { WERR_IPSEC_IKE_NEGOTIATION_PENDING, "The IKE negotiation is in progress." },
+       { WERR_IPSEC_IKE_GENERAL_PROCESSING_ERROR, "General processing error." },
+       { WERR_IPSEC_IKE_TIMED_OUT, "Negotiation timed out." },
+       { WERR_IPSEC_IKE_NO_CERT, "The IKE failed to find a valid machine certificate. Contact your network security administrator about installing a valid certificate in the appropriate certificate store." },
+       { WERR_IPSEC_IKE_SA_DELETED, "The IKE security association (SA) was deleted by a peer before it was completely established." },
+       { WERR_IPSEC_IKE_SA_REAPED, "The IKE SA was deleted before it was completely established." },
+       { WERR_IPSEC_IKE_MM_ACQUIRE_DROP, "The negotiation request sat in the queue too long." },
+       { WERR_IPSEC_IKE_QM_ACQUIRE_DROP, "The negotiation request sat in the queue too long." },
+       { WERR_IPSEC_IKE_QUEUE_DROP_MM, "The negotiation request sat in the queue too long." },
+       { WERR_IPSEC_IKE_QUEUE_DROP_NO_MM, "The negotiation request sat in the queue too long." },
+       { WERR_IPSEC_IKE_DROP_NO_RESPONSE, "There was no response from a peer." },
+       { WERR_IPSEC_IKE_MM_DELAY_DROP, "The negotiation took too long." },
+       { WERR_IPSEC_IKE_QM_DELAY_DROP, "The negotiation took too long." },
+       { WERR_IPSEC_IKE_ERROR, "An unknown error occurred." },
+       { WERR_IPSEC_IKE_CRL_FAILED, "The certificate revocation check failed." },
+       { WERR_IPSEC_IKE_INVALID_KEY_USAGE, "Invalid certificate key usage." },
+       { WERR_IPSEC_IKE_INVALID_CERT_TYPE, "Invalid certificate type." },
+       { WERR_IPSEC_IKE_NO_PRIVATE_KEY, "The IKE negotiation failed because the machine certificate used does not have a private key. IPsec certificates require a private key. Contact your network security administrator about a certificate that has a private key." },
+       { WERR_IPSEC_IKE_DH_FAIL, "There was a failure in the Diffie-Hellman computation." },
+       { WERR_IPSEC_IKE_INVALID_HEADER, "Invalid header." },
+       { WERR_IPSEC_IKE_NO_POLICY, "No policy configured." },
+       { WERR_IPSEC_IKE_INVALID_SIGNATURE, "Failed to verify signature." },
+       { WERR_IPSEC_IKE_KERBEROS_ERROR, "Failed to authenticate using Kerberos." },
+       { WERR_IPSEC_IKE_NO_PUBLIC_KEY, "The peer\'s certificate did not have a public key." },
+       { WERR_IPSEC_IKE_PROCESS_ERR, "Error processing the error payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_SA, "Error processing the SA payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_PROP, "Error processing the proposal payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_TRANS, "Error processing the transform payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_KE, "Error processing the key exchange payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_ID, "Error processing the ID payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_CERT, "Error processing the certification payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_CERT_REQ, "Error processing the certificate request payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_HASH, "Error processing the hash payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_SIG, "Error processing the signature payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_NONCE, "Error processing the nonce payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_NOTIFY, "Error processing the notify payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_DELETE, "Error processing the delete payload." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_VENDOR, "Error processing the VendorId payload." },
+       { WERR_IPSEC_IKE_INVALID_PAYLOAD, "Invalid payload received." },
+       { WERR_IPSEC_IKE_LOAD_SOFT_SA, "Soft SA loaded." },
+       { WERR_IPSEC_IKE_SOFT_SA_TORN_DOWN, "Soft SA torn down." },
+       { WERR_IPSEC_IKE_INVALID_COOKIE, "Invalid cookie received." },
+       { WERR_IPSEC_IKE_NO_PEER_CERT, "Peer failed to send valid machine certificate." },
+       { WERR_IPSEC_IKE_PEER_CRL_FAILED, "Certification revocation check of peer\'s certificate failed." },
+       { WERR_IPSEC_IKE_POLICY_CHANGE, "New policy invalidated SAs formed with the old policy." },
+       { WERR_IPSEC_IKE_NO_MM_POLICY, "There is no available main mode IKE policy." },
+       { WERR_IPSEC_IKE_NOTCBPRIV, "Failed to enabled trusted computer base (TCB) privilege." },
+       { WERR_IPSEC_IKE_SECLOADFAIL, "Failed to load SECURITY.DLL." },
+       { WERR_IPSEC_IKE_FAILSSPINIT, "Failed to obtain the security function table dispatch address from the SSPI." },
+       { WERR_IPSEC_IKE_FAILQUERYSSP, "Failed to query the Kerberos package to obtain the max token size." },
+       { WERR_IPSEC_IKE_SRVACQFAIL, "Failed to obtain the Kerberos server credentials for the Internet Security Association and Key Management Protocol (ISAKMP)/ERROR_IPSEC_IKE service. Kerberos authentication will not function. The most likely reason for this is lack of domain membership. This is normal if your computer is a member of a workgroup." },
+       { WERR_IPSEC_IKE_SRVQUERYCRED, "Failed to determine the SSPI principal name for ISAKMP/ERROR_IPSEC_IKE service (QueryCredentialsAttributes)." },
+       { WERR_IPSEC_IKE_GETSPIFAIL, "Failed to obtain a new service provider interface (SPI) for the inbound SA from the IPsec driver. The most common cause for this is that the driver does not have the correct filter. Check your policy to verify the filters." },
+       { WERR_IPSEC_IKE_INVALID_FILTER, "Given filter is invalid" },
+       { WERR_IPSEC_IKE_OUT_OF_MEMORY, "Memory allocation failed." },
+       { WERR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED, "Failed to add an SA to the IPSec driver. The most common cause for this is if the IKE negotiation took too long to complete. If the problem persists, reduce the load on the faulting machine." },
+       { WERR_IPSEC_IKE_INVALID_POLICY, "Invalid policy." },
+       { WERR_IPSEC_IKE_UNKNOWN_DOI, "Invalid digital object identifier (DOI)." },
+       { WERR_IPSEC_IKE_INVALID_SITUATION, "Invalid situation." },
+       { WERR_IPSEC_IKE_DH_FAILURE, "Diffie-Hellman failure." },
+       { WERR_IPSEC_IKE_INVALID_GROUP, "Invalid Diffie-Hellman group." },
+       { WERR_IPSEC_IKE_ENCRYPT, "Error encrypting payload." },
+       { WERR_IPSEC_IKE_DECRYPT, "Error decrypting payload." },
+       { WERR_IPSEC_IKE_POLICY_MATCH, "Policy match error." },
+       { WERR_IPSEC_IKE_UNSUPPORTED_ID, "Unsupported ID." },
+       { WERR_IPSEC_IKE_INVALID_HASH, "Hash verification failed." },
+       { WERR_IPSEC_IKE_INVALID_HASH_ALG, "Invalid hash algorithm." },
+       { WERR_IPSEC_IKE_INVALID_HASH_SIZE, "Invalid hash size." },
+       { WERR_IPSEC_IKE_INVALID_ENCRYPT_ALG, "Invalid encryption algorithm." },
+       { WERR_IPSEC_IKE_INVALID_AUTH_ALG, "Invalid authentication algorithm." },
+       { WERR_IPSEC_IKE_INVALID_SIG, "Invalid certificate signature." },
+       { WERR_IPSEC_IKE_LOAD_FAILED, "Load failed." },
+       { WERR_IPSEC_IKE_RPC_DELETE, "Deleted by using an RPC call." },
+       { WERR_IPSEC_IKE_BENIGN_REINIT, "A temporary state was created to perform reinitialization. This is not a real failure." },
+       { WERR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY, "The lifetime value received in the Responder Lifetime Notify is below the Windows 2000 configured minimum value. Fix the policy on the peer machine." },
+       { WERR_IPSEC_IKE_INVALID_CERT_KEYLEN, "Key length in the certificate is too small for configured security requirements." },
+       { WERR_IPSEC_IKE_MM_LIMIT, "Maximum number of established MM SAs to peer exceeded." },
+       { WERR_IPSEC_IKE_NEGOTIATION_DISABLED, "The IKE received a policy that disables negotiation." },
+       { WERR_IPSEC_IKE_QM_LIMIT, "Reached maximum quick mode limit for the main mode. New main mode will be started." },
+       { WERR_IPSEC_IKE_MM_EXPIRED, "Main mode SA lifetime expired or the peer sent a main mode delete." },
+       { WERR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID, "Main mode SA assumed to be invalid because peer stopped responding." },
+       { WERR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH, "Certificate does not chain to a trusted root in IPsec policy." },
+       { WERR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID, "Received unexpected message ID." },
+       { WERR_IPSEC_IKE_INVALID_UMATTS, "Received invalid AuthIP user mode attributes." },
+       { WERR_IPSEC_IKE_DOS_COOKIE_SENT, "Sent DOS cookie notify to initiator." },
+       { WERR_IPSEC_IKE_SHUTTING_DOWN, "The IKE service is shutting down." },
+       { WERR_IPSEC_IKE_CGA_AUTH_FAILED, "Could not verify the binding between the color graphics adapter (CGA) address and the certificate." },
+       { WERR_IPSEC_IKE_PROCESS_ERR_NATOA, "Error processing the NatOA payload." },
+       { WERR_IPSEC_IKE_INVALID_MM_FOR_QM, "The parameters of the main mode are invalid for this quick mode." },
+       { WERR_IPSEC_IKE_QM_EXPIRED, "The quick mode SA was expired by the IPsec driver." },
+       { WERR_IPSEC_IKE_TOO_MANY_FILTERS, "Too many dynamically added IKEEXT filters were detected." },
+       { WERR_IPSEC_IKE_NEG_STATUS_END, "ERROR_IPSEC_IKE_NEG_STATUS_END" },
+       { WERR_SXS_SECTION_NOT_FOUND, "The requested section was not present in the activation context." },
+       { WERR_SXS_CANT_GEN_ACTCTX, "The application has failed to start because its side-by-side configuration is incorrect. See the application event log for more detail." },
+       { WERR_SXS_INVALID_ACTCTXDATA_FORMAT, "The application binding data format is invalid." },
+       { WERR_SXS_ASSEMBLY_NOT_FOUND, "The referenced assembly is not installed on your system." },
+       { WERR_SXS_MANIFEST_FORMAT_ERROR, "The manifest file does not begin with the required tag and format information." },
+       { WERR_SXS_MANIFEST_PARSE_ERROR, "The manifest file contains one or more syntax errors." },
+       { WERR_SXS_ACTIVATION_CONTEXT_DISABLED, "The application attempted to activate a disabled activation context." },
+       { WERR_SXS_KEY_NOT_FOUND, "The requested lookup key was not found in any active activation context." },
+       { WERR_SXS_VERSION_CONFLICT, "A component version required by the application conflicts with another active component version." },
+       { WERR_SXS_WRONG_SECTION_TYPE, "The type requested activation context section does not match the query API used." },
+       { WERR_SXS_THREAD_QUERIES_DISABLED, "Lack of system resources has required isolated activation to be disabled for the current thread of execution." },
+       { WERR_SXS_PROCESS_DEFAULT_ALREADY_SET, "An attempt to set the process default activation context failed because the process default activation context was already set." },
+       { WERR_SXS_UNKNOWN_ENCODING_GROUP, "The encoding group identifier specified is not recognized." },
+       { WERR_SXS_UNKNOWN_ENCODING, "The encoding requested is not recognized." },
+       { WERR_SXS_INVALID_XML_NAMESPACE_URI, "The manifest contains a reference to an invalid URI." },
+       { WERR_SXS_ROOT_MANIFEST_DEPENDENCY_OT_INSTALLED, "The application manifest contains a reference to a dependent assembly that is not installed." },
+       { WERR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED, "The manifest for an assembly used by the application has a reference to a dependent assembly that is not installed." },
+       { WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE, "The manifest contains an attribute for the assembly identity that is not valid." },
+       { WERR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE, "The manifest is missing the required default namespace specification on the assembly element." },
+       { WERR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE, "The manifest has a default namespace specified on the assembly element but its value is not urn:schemas-microsoft-com:asm.v1\".\"" },
+       { WERR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT, "The private manifest probed has crossed the reparse-point-associated path." },
+       { WERR_SXS_DUPLICATE_DLL_NAME, "Two or more components referenced directly or indirectly by the application manifest have files by the same name." },
+       { WERR_SXS_DUPLICATE_WINDOWCLASS_NAME, "Two or more components referenced directly or indirectly by the application manifest have window classes with the same name." },
+       { WERR_SXS_DUPLICATE_CLSID, "Two or more components referenced directly or indirectly by the application manifest have the same COM server CLSIDs." },
+       { WERR_SXS_DUPLICATE_IID, "Two or more components referenced directly or indirectly by the application manifest have proxies for the same COM interface IIDs." },
+       { WERR_SXS_DUPLICATE_TLBID, "Two or more components referenced directly or indirectly by the application manifest have the same COM type library TLBIDs." },
+       { WERR_SXS_DUPLICATE_PROGID, "Two or more components referenced directly or indirectly by the application manifest have the same COM ProgIDs." },
+       { WERR_SXS_DUPLICATE_ASSEMBLY_NAME, "Two or more components referenced directly or indirectly by the application manifest are different versions of the same component, which is not permitted." },
+       { WERR_SXS_FILE_HASH_MISMATCH, "A component\'s file does not match the verification information present in the component manifest." },
+       { WERR_SXS_POLICY_PARSE_ERROR, "The policy manifest contains one or more syntax errors." },
+       { WERR_SXS_XML_E_MISSINGQUOTE, "Manifest Parse Error: A string literal was expected, but no opening quotation mark was found." },
+       { WERR_SXS_XML_E_COMMENTSYNTAX, "Manifest Parse Error: Incorrect syntax was used in a comment." },
+       { WERR_SXS_XML_E_BADSTARTNAMECHAR, "Manifest Parse Error: A name started with an invalid character." },
+       { WERR_SXS_XML_E_BADNAMECHAR, "Manifest Parse Error: A name contained an invalid character." },
+       { WERR_SXS_XML_E_BADCHARINSTRING, "Manifest Parse Error: A string literal contained an invalid character." },
+       { WERR_SXS_XML_E_XMLDECLSYNTAX, "Manifest Parse Error: Invalid syntax for an XML declaration." },
+       { WERR_SXS_XML_E_BADCHARDATA, "Manifest Parse Error: An Invalid character was found in text content." },
+       { WERR_SXS_XML_E_MISSINGWHITESPACE, "Manifest Parse Error: Required white space was missing." },
+       { WERR_SXS_XML_E_EXPECTINGTAGEND, "Manifest Parse Error: The angle bracket (>) character was expected." },
+       { WERR_SXS_XML_E_MISSINGSEMICOLON, "Manifest Parse Error: A semicolon (;) was expected." },
+       { WERR_SXS_XML_E_UNBALANCEDPAREN, "Manifest Parse Error: Unbalanced parentheses." },
+       { WERR_SXS_XML_E_INTERNALERROR, "Manifest Parse Error: Internal error." },
+       { WERR_SXS_XML_E_UNEXPECTED_WHITESPACE, "Manifest Parse Error: Whitespace is not allowed at this location." },
+       { WERR_SXS_XML_E_INCOMPLETE_ENCODING, "Manifest Parse Error: End of file reached in invalid state for current encoding." },
+       { WERR_SXS_XML_E_MISSING_PAREN, "Manifest Parse Error: Missing parenthesis." },
+       { WERR_SXS_XML_E_EXPECTINGCLOSEQUOTE, "Manifest Parse Error: A single (\') or double (\") quotation mark is missing." },
+       { WERR_SXS_XML_E_MULTIPLE_COLONS, "Manifest Parse Error: Multiple colons are not allowed in a name." },
+       { WERR_SXS_XML_E_INVALID_DECIMAL, "Manifest Parse Error: Invalid character for decimal digit." },
+       { WERR_SXS_XML_E_INVALID_HEXIDECIMAL, "Manifest Parse Error: Invalid character for hexadecimal digit." },
+       { WERR_SXS_XML_E_INVALID_UNICODE, "Manifest Parse Error: Invalid Unicode character value for this platform." },
+       { WERR_SXS_XML_E_WHITESPACEORQUESTIONMARK, "Manifest Parse Error: Expecting whitespace or question mark (?)." },
+       { WERR_SXS_XML_E_UNEXPECTEDENDTAG, "Manifest Parse Error: End tag was not expected at this location." },
+       { WERR_SXS_XML_E_UNCLOSEDTAG, "Manifest Parse Error: The following tags were not closed: %1." },
+       { WERR_SXS_XML_E_DUPLICATEATTRIBUTE, "Manifest Parse Error: Duplicate attribute." },
+       { WERR_SXS_XML_E_MULTIPLEROOTS, "Manifest Parse Error: Only one top-level element is allowed in an XML document." },
+       { WERR_SXS_XML_E_INVALIDATROOTLEVEL, "Manifest Parse Error: Invalid at the top level of the document." },
+       { WERR_SXS_XML_E_BADXMLDECL, "Manifest Parse Error: Invalid XML declaration." },
+       { WERR_SXS_XML_E_MISSINGROOT, "Manifest Parse Error: XML document must have a top-level element." },
+       { WERR_SXS_XML_E_UNEXPECTEDEOF, "Manifest Parse Error: Unexpected end of file." },
+       { WERR_SXS_XML_E_BADPEREFINSUBSET, "Manifest Parse Error: Parameter entities cannot be used inside markup declarations in an internal subset." },
+       { WERR_SXS_XML_E_UNCLOSEDSTARTTAG, "Manifest Parse Error: Element was not closed." },
+       { WERR_SXS_XML_E_UNCLOSEDENDTAG, "Manifest Parse Error: End element was missing the angle bracket (>) character." },
+       { WERR_SXS_XML_E_UNCLOSEDSTRING, "Manifest Parse Error: A string literal was not closed." },
+       { WERR_SXS_XML_E_UNCLOSEDCOMMENT, "Manifest Parse Error: A comment was not closed." },
+       { WERR_SXS_XML_E_UNCLOSEDDECL, "Manifest Parse Error: A declaration was not closed." },
+       { WERR_SXS_XML_E_UNCLOSEDCDATA, "Manifest Parse Error: A CDATA section was not closed." },
+       { WERR_SXS_XML_E_RESERVEDNAMESPACE, "Manifest Parse Error: The namespace prefix is not allowed to start with the reserved string xml\".\"" },
+       { WERR_SXS_XML_E_INVALIDENCODING, "Manifest Parse Error: System does not support the specified encoding." },
+       { WERR_SXS_XML_E_INVALIDSWITCH, "Manifest Parse Error: Switch from current encoding to specified encoding not supported." },
+       { WERR_SXS_XML_E_BADXMLCASE, "Manifest Parse Error: The name \"xml\" is reserved and must be lowercase." },
+       { WERR_SXS_XML_E_INVALID_STANDALONE, "Manifest Parse Error: The stand-alone attribute must have the value \"yes\" or \"no\"." },
+       { WERR_SXS_XML_E_UNEXPECTED_STANDALONE, "Manifest Parse Error: The stand-alone attribute cannot be used in external entities." },
+       { WERR_SXS_XML_E_INVALID_VERSION, "Manifest Parse Error: Invalid version number." },
+       { WERR_SXS_XML_E_MISSINGEQUALS, "Manifest Parse Error: Missing equal sign (=) between the attribute and the attribute value." },
+       { WERR_SXS_PROTECTION_RECOVERY_FAILED, "Assembly Protection Error: Unable to recover the specified assembly." },
+       { WERR_SXS_PROTECTION_PUBLIC_KEY_OO_SHORT, "Assembly Protection Error: The public key for an assembly was too short to be allowed." },
+       { WERR_SXS_PROTECTION_CATALOG_NOT_VALID, "Assembly Protection Error: The catalog for an assembly is not valid, or does not match the assembly\'s manifest." },
+       { WERR_SXS_UNTRANSLATABLE_HRESULT, "An HRESULT could not be translated to a corresponding Win32 error code." },
+       { WERR_SXS_PROTECTION_CATALOG_FILE_MISSING, "Assembly Protection Error: The catalog for an assembly is missing." },
+       { WERR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE, "The supplied assembly identity is missing one or more attributes that must be present in this context." },
+       { WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME, "The supplied assembly identity has one or more attribute names that contain characters not permitted in XML names." },
+       { WERR_SXS_ASSEMBLY_MISSING, "The referenced assembly could not be found." },
+       { WERR_SXS_CORRUPT_ACTIVATION_STACK, "The activation context activation stack for the running thread of execution is corrupt." },
+       { WERR_SXS_CORRUPTION, "The application isolation metadata for this process or thread has become corrupt." },
+       { WERR_SXS_EARLY_DEACTIVATION, "The activation context being deactivated is not the most recently activated one." },
+       { WERR_SXS_INVALID_DEACTIVATION, "The activation context being deactivated is not active for the current thread of execution." },
+       { WERR_SXS_MULTIPLE_DEACTIVATION, "The activation context being deactivated has already been deactivated." },
+       { WERR_SXS_PROCESS_TERMINATION_REQUESTED, "A component used by the isolation facility has requested to terminate the process." },
+       { WERR_SXS_RELEASE_ACTIVATION_ONTEXT, "A kernel mode component is releasing a reference on an activation context." },
+       { WERR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY, "The activation context of the system default assembly could not be generated." },
+       { WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE, "The value of an attribute in an identity is not within the legal range." },
+       { WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME, "The name of an attribute in an identity is not within the legal range." },
+       { WERR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE, "An identity contains two definitions for the same attribute." },
+       { WERR_SXS_IDENTITY_PARSE_ERROR, "The identity string is malformed. This may be due to a trailing comma, more than two unnamed attributes, a missing attribute name, or a missing attribute value." },
+       { WERR_MALFORMED_SUBSTITUTION_STRING, "A string containing localized substitutable content was malformed. Either a dollar sign ($) was followed by something other than a left parenthesis or another dollar sign, or a substitution\'s right parenthesis was not found." },
+       { WERR_SXS_INCORRECT_PUBLIC_KEY_OKEN, "The public key token does not correspond to the public key specified." },
+       { WERR_UNMAPPED_SUBSTITUTION_STRING, "A substitution string had no mapping." },
+       { WERR_SXS_ASSEMBLY_NOT_LOCKED, "The component must be locked before making the request." },
+       { WERR_SXS_COMPONENT_STORE_CORRUPT, "The component store has been corrupted." },
+       { WERR_ADVANCED_INSTALLER_FAILED, "An advanced installer failed during setup or servicing." },
+       { WERR_XML_ENCODING_MISMATCH, "The character encoding in the XML declaration did not match the encoding used in the document." },
+       { WERR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT, "The identities of the manifests are identical, but the contents are different." },
+       { WERR_SXS_IDENTITIES_DIFFERENT, "The component identities are different." },
+       { WERR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT, "The assembly is not a deployment." },
+       { WERR_SXS_FILE_NOT_PART_OF_ASSEMBLY, "The file is not a part of the assembly." },
+       { WERR_SXS_MANIFEST_TOO_BIG, "The size of the manifest exceeds the maximum allowed." },
+       { WERR_SXS_SETTING_NOT_REGISTERED, "The setting is not registered." },
+       { WERR_SXS_TRANSACTION_CLOSURE_INCOMPLETE, "One or more required members of the transaction are not present." },
+       { WERR_EVT_INVALID_CHANNEL_PATH, "The specified channel path is invalid." },
+       { WERR_EVT_INVALID_QUERY, "The specified query is invalid." },
+       { WERR_EVT_PUBLISHER_METADATA_NOT_FOUND, "The publisher metadata cannot be found in the resource." },
+       { WERR_EVT_EVENT_TEMPLATE_NOT_FOUND, "The template for an event definition cannot be found in the resource (error = %1)." },
+       { WERR_EVT_INVALID_PUBLISHER_NAME, "The specified publisher name is invalid." },
+       { WERR_EVT_INVALID_EVENT_DATA, "The event data raised by the publisher is not compatible with the event template definition in the publisher\'s manifest." },
+       { WERR_EVT_CHANNEL_NOT_FOUND, "The specified channel could not be found. Check channel configuration." },
+       { WERR_EVT_MALFORMED_XML_TEXT, "The specified XML text was not well-formed. See extended error for more details." },
+       { WERR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL, "The caller is trying to subscribe to a direct channel which is not allowed. The events for a direct channel go directly to a log file and cannot be subscribed to." },
+       { WERR_EVT_CONFIGURATION_ERROR, "Configuration error." },
+       { WERR_EVT_QUERY_RESULT_STALE, "The query result is stale or invalid. This may be due to the log being cleared or rolling over after the query result was created. Users should handle this code by releasing the query result object and reissuing the query." },
+       { WERR_EVT_QUERY_RESULT_INVALID_POSITION, "Query result is currently at an invalid position." },
+       { WERR_EVT_NON_VALIDATING_MSXML, "Registered Microsoft XML (MSXML) does not support validation." },
+       { WERR_EVT_FILTER_ALREADYSCOPED, "An expression can only be followed by a change-of-scope operation if it itself evaluates to a node set and is not already part of some other change-of-scope operation." },
+       { WERR_EVT_FILTER_NOTELTSET, "Cannot perform a step operation from a term that does not represent an element set." },
+       { WERR_EVT_FILTER_INVARG, "Left side arguments to binary operators must be either attributes, nodes, or variables and right side arguments must be constants." },
+       { WERR_EVT_FILTER_INVTEST, "A step operation must involve either a node test or, in the case of a predicate, an algebraic expression against which to test each node in the node set identified by the preceding node set can be evaluated." },
+       { WERR_EVT_FILTER_INVTYPE, "This data type is currently unsupported." },
+       { WERR_EVT_FILTER_PARSEERR, "A syntax error occurred at position %1!d!" },
+       { WERR_EVT_FILTER_UNSUPPORTEDOP, "This operator is unsupported by this implementation of the filter." },
+       { WERR_EVT_FILTER_UNEXPECTEDTOKEN, "The token encountered was unexpected." },
+       { WERR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL, "The requested operation cannot be performed over an enabled direct channel. The channel must first be disabled before performing the requested operation." },
+       { WERR_EVT_INVALID_CHANNEL_PROPERTY_VALUE, "Channel property %1!s! contains an invalid value. The value has an invalid type, is outside the valid range, cannot be updated, or is not supported by this type of channel." },
+       { WERR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE, "Publisher property %1!s! contains an invalid value. The value has an invalid type, is outside the valid range, cannot be updated, or is not supported by this type of publisher." },
+       { WERR_EVT_CHANNEL_CANNOT_ACTIVATE, "The channel fails to activate." },
+       { WERR_EVT_FILTER_TOO_COMPLEX, "The xpath expression exceeded supported complexity. Simplify it or split it into two or more simple expressions." },
+       { WERR_EVT_MESSAGE_NOT_FOUND, "The message resource is present but the message is not found in the string or message table." },
+       { WERR_EVT_MESSAGE_ID_NOT_FOUND, "The message ID for the desired message could not be found." },
+       { WERR_EVT_UNRESOLVED_VALUE_INSERT, "The substitution string for the insert index (%1) could not be found." },
+       { WERR_EVT_UNRESOLVED_PARAMETER_INSERT, "The description string for the parameter reference (%1) could not be found." },
+       { WERR_EVT_MAX_INSERTS_REACHED, "The maximum number of replacements has been reached." },
+       { WERR_EVT_EVENT_DEFINITION_NOT_OUND, "The event definition could not be found for the event ID (%1)." },
+       { WERR_EVT_MESSAGE_LOCALE_NOT_FOUND, "The locale-specific resource for the desired message is not present." },
+       { WERR_EVT_VERSION_TOO_OLD, "The resource is too old to be compatible." },
+       { WERR_EVT_VERSION_TOO_NEW, "The resource is too new to be compatible." },
+       { WERR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY, "The channel at index %1 of the query cannot be opened." },
+       { WERR_EVT_PUBLISHER_DISABLED, "The publisher has been disabled and its resource is not available. This usually occurs when the publisher is in the process of being uninstalled or upgraded." },
+       { WERR_EC_SUBSCRIPTION_CANNOT_ACTIVATE, "The subscription fails to activate." },
+       { WERR_EC_LOG_DISABLED, "The log of the subscription is in a disabled state and events cannot be forwarded to it. The log must first be enabled before the subscription can be activated." },
+       { WERR_MUI_FILE_NOT_FOUND, "The resource loader failed to find the Multilingual User Interface (MUI) file." },
+       { WERR_MUI_INVALID_FILE, "The resource loader failed to load the MUI file because the file failed to pass validation." },
+       { WERR_MUI_INVALID_RC_CONFIG, "The release candidate (RC) manifest is corrupted with garbage data, is an unsupported version, or is missing a required item." },
+       { WERR_MUI_INVALID_LOCALE_NAME, "The RC manifest has an invalid culture name." },
+       { WERR_MUI_INVALID_ULTIMATEFALLBACK_NAME, "The RC Manifest has an invalid ultimate fallback name." },
+       { WERR_MUI_FILE_NOT_LOADED, "The resource loader cache does not have a loaded MUI entry." },
+       { WERR_RESOURCE_ENUM_USER_STOP, "The user stopped resource enumeration." },
+       { WERR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED, "User interface language installation failed." },
+       { WERR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME, "Locale installation failed." },
+       { WERR_MCA_INVALID_CAPABILITIES_STRING, "The monitor returned a DDC/CI capabilities string that did not comply with the ACCESS.bus 3.0, DDC/CI 1.1, or MCCS 2 Revision 1 specification." },
+       { WERR_MCA_INVALID_VCP_VERSION, "The monitor\'s VCP version (0xDF) VCP code returned an invalid version value." },
+       { WERR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION, "The monitor does not comply with the MCCS specification it claims to support." },
+       { WERR_MCA_MCCS_VERSION_MISMATCH, "The MCCS version in a monitor\'s mccs_ver capability does not match the MCCS version the monitor reports when the VCP version (0xDF) VCP code is used." },
+       { WERR_MCA_UNSUPPORTED_MCCS_VERSION, "The monitor configuration API works only with monitors that support the MCCS 1.0, MCCS 2.0, or MCCS 2.0 Revision 1 specifications." },
+       { WERR_MCA_INTERNAL_ERROR, "An internal monitor configuration API error occurred." },
+       { WERR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED, "The monitor returned an invalid monitor technology type. CRT, plasma, and LCD (TFT) are examples of monitor technology types. This error implies that the monitor violated the MCCS 2.0 or MCCS 2.0 Revision 1 specification." },
+       { WERR_MCA_UNSUPPORTED_COLOR_TEMPERATURE, "The SetMonitorColorTemperature() caller passed a color temperature to it that the current monitor did not support. CRT, plasma, and LCD (TFT) are examples of monitor technology types. This error implies that the monitor violated the MCCS 2.0 or MCCS 2.0 Revision 1 specification." },
+       { WERR_AMBIGUOUS_SYSTEM_DEVICE, "The requested system device cannot be identified due to multiple indistinguishable devices potentially matching the identification criteria." },
+       { WERR_SYSTEM_DEVICE_NOT_FOUND, "The requested system device cannot be found." },
+       /* END GENERATED-WIN32-ERROR-CODES-DESC */
 };
 
 

diff --git a/libcli/util/ntstatus.h b/libcli/util/ntstatus.h
index 1025f472104f2ba027a680e4191a9efaa20c5aed..88b4353c1d1c02439a3387df11ebdbe3a31aab08 100644 (file)
--- a/libcli/util/ntstatus.h
+++ b/libcli/util/ntstatus.h
@@ -674,6 +674,13 @@ extern bool ntstatus_check_dos_mapping;
        }\
 } while (0)
 
+#define NT_STATUS_NOT_OK_RETURN_AND_FREE(x, ctx) do {  \
+       if (!NT_STATUS_IS_OK(x)) {\
+               talloc_free(ctx); \
+               return x;\
+       }\
+} while (0)
+
 #define NT_STATUS_IS_ERR_RETURN(x) do { \
        if (NT_STATUS_IS_ERR(x)) {\
                return x;\

diff --git a/libcli/util/werror.h b/libcli/util/werror.h
index d64746b363fe70845cdc410660994706e3933a69..ac4fb3725773e9aa80c4fc16ff6d116d97614abf 100644 (file)
--- a/libcli/util/werror.h
+++ b/libcli/util/werror.h
@@ -159,9 +159,9 @@ typedef uint32_t WERROR;
 #define WERR_INVALID_FORM_NAME W_ERROR(0x0000076E)
 #define WERR_INVALID_FORM_SIZE W_ERROR(0x0000076F)
 #define WERR_PASSWORD_MUST_CHANGE W_ERROR(0x00000773)
+#define WERR_DOMAIN_CONTROLLER_NOT_FOUND W_ERROR(0x00000774)
 #define WERR_ACCOUNT_LOCKED_OUT W_ERROR(0x00000775)
 
-#define WERR_DOMAIN_CONTROLLER_NOT_FOUND W_ERROR(0x00000995) /* Error code is wrong, should be  0x00000774 (1908)*/
 
 #define WERR_DEVICE_NOT_AVAILABLE W_ERROR(0x000010DF)
 
@@ -212,9 +212,9 @@ typedef uint32_t WERROR;
 #define WERR_ALREADY_SHARED            W_ERROR(0x00000846)
 #define WERR_JOB_NOT_FOUND             W_ERROR(0x00000867)
 #define WERR_DEST_NOT_FOUND            W_ERROR(0x00000868)
-#define WERR_GROUP_NOT_FOUND           W_ERROR(0x000008AC)
+#define WERR_GROUPNOTFOUND             W_ERROR(0x000008AC)
 #define WERR_USER_NOT_FOUND            W_ERROR(0x000008AD)
-#define WERR_USER_EXISTS               W_ERROR(0x000008B0)
+#define WERR_USEREXISTS                        W_ERROR(0x000008B0)
 #define WERR_NOT_CONNECTED             W_ERROR(0x000008CA)
 #define WERR_NAME_NOT_FOUND            W_ERROR(0x000008E1)
 #define WERR_NET_NAME_NOT_FOUND                W_ERROR(0x00000906)
@@ -222,7 +222,7 @@ typedef uint32_t WERROR;
 #define WERR_DEVICE_NOT_SHARED         W_ERROR(0x00000907)
 #define WERR_FID_NOT_FOUND             W_ERROR(0x0000090A)
 #define WERR_NOT_LOCAL_DOMAIN          W_ERROR(0x00000910)
-#define WERR_DC_NOT_FOUND              W_ERROR(0x00000995)
+#define WERR_DCNOTFOUND                        W_ERROR(0x00000995)
 #define WERR_TIME_DIFF_AT_DC           W_ERROR(0x00000999)
 #define WERR_DFS_NO_SUCH_VOL           W_ERROR(0x00000A66)
 #define WERR_DFS_NO_SUCH_SHARE         W_ERROR(0x00000A69)
@@ -292,9 +292,9 @@ typedef uint32_t WERROR;
 #define WERR_DS_DUP_MSDS_INTID W_ERROR(0x00002195)
 
 /* FRS errors */
-#define WERR_FRS_INSUFFICIENT_PRIV W_ERROR(FRS_ERR_BASE+7)
-#define WERR_FRS_SYSVOL_IS_BUSY W_ERROR(FRS_ERR_BASE+15)
-#define WERR_FRS_INVALID_SERVICE_PARAMETER W_ERROR(FRS_ERR_BASE+17)
+#define WERR_FRS_INSUFFICIENT_PRIV W_ERROR(0x00001F47)
+#define WERR_FRS_SYSVOL_IS_BUSY W_ERROR(0x00001F4F)
+#define WERR_FRS_INVALID_SERVICE_PARAMETER W_ERROR(0x00001F51)
 
 /* RPC/COM/OLE HRESULT error codes */
 /* RPC errors */
@@ -312,6 +312,2367 @@ typedef uint32_t WERROR;
 /* Generic error code aliases */
 #define WERR_FOOBAR WERR_GENERAL_FAILURE
 
+/*****************************************************************************
+ Auto-generated Win32 error from:
+ http://msdn.microsoft.com/en-us/library/cc231199%28PROT.10%29.aspx
+ *****************************************************************************/
+/* BEGIN GENERATED-WIN32-ERROR-CODES */
+#define WERR_NERR_SUCCESS      W_ERROR(0x00000000)
+#define WERR_INVALID_FUNCTION  W_ERROR(0x00000001)
+#define WERR_FILE_NOT_FOUND    W_ERROR(0x00000002)
+#define WERR_PATH_NOT_FOUND    W_ERROR(0x00000003)
+#define WERR_TOO_MANY_OPEN_FILES       W_ERROR(0x00000004)
+#define WERR_INVALID_HANDLE    W_ERROR(0x00000006)
+#define WERR_ARENA_TRASHED     W_ERROR(0x00000007)
+#define WERR_NOT_ENOUGH_MEMORY W_ERROR(0x00000008)
+#define WERR_INVALID_BLOCK     W_ERROR(0x00000009)
+#define WERR_BAD_ENVIRONMENT   W_ERROR(0x0000000A)
+#define WERR_BAD_FORMAT        W_ERROR(0x0000000B)
+#define WERR_INVALID_ACCESS    W_ERROR(0x0000000C)
+#define WERR_INVALID_DATA      W_ERROR(0x0000000D)
+#define WERR_OUTOFMEMORY       W_ERROR(0x0000000E)
+#define WERR_INVALID_DRIVE     W_ERROR(0x0000000F)
+#define WERR_CURRENT_DIRECTORY W_ERROR(0x00000010)
+#define WERR_NOT_SAME_DEVICE   W_ERROR(0x00000011)
+#define WERR_NO_MORE_FILES     W_ERROR(0x00000012)
+#define WERR_WRITE_PROTECT     W_ERROR(0x00000013)
+#define WERR_BAD_UNIT  W_ERROR(0x00000014)
+#define WERR_NOT_READY W_ERROR(0x00000015)
+#define WERR_BAD_COMMAND       W_ERROR(0x00000016)
+#define WERR_CRC       W_ERROR(0x00000017)
+#define WERR_BAD_LENGTH        W_ERROR(0x00000018)
+#define WERR_SEEK      W_ERROR(0x00000019)
+#define WERR_NOT_DOS_DISK      W_ERROR(0x0000001A)
+#define WERR_SECTOR_NOT_FOUND  W_ERROR(0x0000001B)
+#define WERR_OUT_OF_PAPER      W_ERROR(0x0000001C)
+#define WERR_WRITE_FAULT       W_ERROR(0x0000001D)
+#define WERR_READ_FAULT        W_ERROR(0x0000001E)
+#define WERR_GEN_FAILURE       W_ERROR(0x0000001F)
+#define WERR_SHARING_VIOLATION W_ERROR(0x00000020)
+#define WERR_LOCK_VIOLATION    W_ERROR(0x00000021)
+#define WERR_WRONG_DISK        W_ERROR(0x00000022)
+#define WERR_SHARING_BUFFER_EXCEEDED   W_ERROR(0x00000024)
+#define WERR_HANDLE_EOF        W_ERROR(0x00000026)
+#define WERR_HANDLE_DISK_FULL  W_ERROR(0x00000027)
+#define WERR_REM_NOT_LIST      W_ERROR(0x00000033)
+#define WERR_NETWORK_BUSY      W_ERROR(0x00000036)
+#define WERR_DEV_NOT_EXIST     W_ERROR(0x00000037)
+#define WERR_TOO_MANY_CMDS     W_ERROR(0x00000038)
+#define WERR_ADAP_HDW_ERR      W_ERROR(0x00000039)
+#define WERR_BAD_REM_ADAP      W_ERROR(0x0000003C)
+#define WERR_PRINT_CANCELLED   W_ERROR(0x0000003F)
+#define WERR_NETNAME_DELETED   W_ERROR(0x00000040)
+#define WERR_NETWORK_ACCESS_DENIED     W_ERROR(0x00000041)
+#define WERR_BAD_DEV_TYPE      W_ERROR(0x00000042)
+#define WERR_BAD_NET_NAME      W_ERROR(0x00000043)
+#define WERR_TOO_MANY_NAMES    W_ERROR(0x00000044)
+#define WERR_TOO_MANY_SESS     W_ERROR(0x00000045)
+#define WERR_SHARING_PAUSED    W_ERROR(0x00000046)
+#define WERR_REQ_NOT_ACCEP     W_ERROR(0x00000047)
+#define WERR_REDIR_PAUSED      W_ERROR(0x00000048)
+#define WERR_CANNOT_MAKE       W_ERROR(0x00000052)
+#define WERR_FAIL_I24  W_ERROR(0x00000053)
+#define WERR_OUT_OF_STRUCTURES W_ERROR(0x00000054)
+#define WERR_ALREADY_ASSIGNED  W_ERROR(0x00000055)
+#define WERR_INVALID_PASSWORD  W_ERROR(0x00000056)
+#define WERR_INVALID_PARAMETER W_ERROR(0x00000057)
+#define WERR_NET_WRITE_FAULT   W_ERROR(0x00000058)
+#define WERR_NO_PROC_SLOTS     W_ERROR(0x00000059)
+#define WERR_TOO_MANY_SEMAPHORES       W_ERROR(0x00000064)
+#define WERR_EXCL_SEM_ALREADY_OWNED    W_ERROR(0x00000065)
+#define WERR_SEM_IS_SET        W_ERROR(0x00000066)
+#define WERR_TOO_MANY_SEM_REQUESTS     W_ERROR(0x00000067)
+#define WERR_INVALID_AT_INTERRUPT_TIME W_ERROR(0x00000068)
+#define WERR_SEM_OWNER_DIED    W_ERROR(0x00000069)
+#define WERR_SEM_USER_LIMIT    W_ERROR(0x0000006A)
+#define WERR_DISK_CHANGE       W_ERROR(0x0000006B)
+#define WERR_DRIVE_LOCKED      W_ERROR(0x0000006C)
+#define WERR_BROKEN_PIPE       W_ERROR(0x0000006D)
+#define WERR_OPEN_FAILED       W_ERROR(0x0000006E)
+#define WERR_BUFFER_OVERFLOW   W_ERROR(0x0000006F)
+#define WERR_DISK_FULL W_ERROR(0x00000070)
+#define WERR_NO_MORE_SEARCH_HANDLES    W_ERROR(0x00000071)
+#define WERR_INVALID_TARGET_HANDLE     W_ERROR(0x00000072)
+#define WERR_INVALID_CATEGORY  W_ERROR(0x00000075)
+#define WERR_INVALID_VERIFY_SWITCH     W_ERROR(0x00000076)
+#define WERR_BAD_DRIVER_LEVEL  W_ERROR(0x00000077)
+#define WERR_INVALID_LEVEL     W_ERROR(0x0000007C)
+#define WERR_NO_VOLUME_LABEL   W_ERROR(0x0000007D)
+#define WERR_MOD_NOT_FOUND     W_ERROR(0x0000007E)
+#define WERR_PROC_NOT_FOUND    W_ERROR(0x0000007F)
+#define WERR_WAIT_NO_CHILDREN  W_ERROR(0x00000080)
+#define WERR_CHILD_NOT_COMPLETE        W_ERROR(0x00000081)
+#define WERR_DIRECT_ACCESS_HANDLE      W_ERROR(0x00000082)
+#define WERR_NEGATIVE_SEEK     W_ERROR(0x00000083)
+#define WERR_SEEK_ON_DEVICE    W_ERROR(0x00000084)
+#define WERR_NOT_SUBSTED       W_ERROR(0x00000089)
+#define WERR_JOIN_TO_JOIN      W_ERROR(0x0000008A)
+#define WERR_SUBST_TO_SUBST    W_ERROR(0x0000008B)
+#define WERR_JOIN_TO_SUBST     W_ERROR(0x0000008C)
+#define WERR_SAME_DRIVE        W_ERROR(0x0000008F)
+#define WERR_DIR_NOT_ROOT      W_ERROR(0x00000090)
+#define WERR_DIR_NOT_EMPTY     W_ERROR(0x00000091)
+#define WERR_IS_SUBST_PATH     W_ERROR(0x00000092)
+#define WERR_IS_JOIN_PATH      W_ERROR(0x00000093)
+#define WERR_PATH_BUSY W_ERROR(0x00000094)
+#define WERR_IS_SUBST_TARGET   W_ERROR(0x00000095)
+#define WERR_SYSTEM_TRACE      W_ERROR(0x00000096)
+#define WERR_INVALID_EVENT_COUNT       W_ERROR(0x00000097)
+#define WERR_TOO_MANY_MUXWAITERS       W_ERROR(0x00000098)
+#define WERR_INVALID_LIST_FORMAT       W_ERROR(0x00000099)
+#define WERR_LABEL_TOO_LONG    W_ERROR(0x0000009A)
+#define WERR_TOO_MANY_TCBS     W_ERROR(0x0000009B)
+#define WERR_SIGNAL_REFUSED    W_ERROR(0x0000009C)
+#define WERR_DISCARDED W_ERROR(0x0000009D)
+#define WERR_NOT_LOCKED        W_ERROR(0x0000009E)
+#define WERR_BAD_THREADID_ADDR W_ERROR(0x0000009F)
+#define WERR_BAD_ARGUMENTS     W_ERROR(0x000000A0)
+#define WERR_BAD_PATHNAME      W_ERROR(0x000000A1)
+#define WERR_SIGNAL_PENDING    W_ERROR(0x000000A2)
+#define WERR_MAX_THRDS_REACHED W_ERROR(0x000000A4)
+#define WERR_LOCK_FAILED       W_ERROR(0x000000A7)
+#define WERR_BUSY      W_ERROR(0x000000AA)
+#define WERR_CANCEL_VIOLATION  W_ERROR(0x000000AD)
+#define WERR_ATOMIC_LOCKS_NOT_SUPPORTED        W_ERROR(0x000000AE)
+#define WERR_INVALID_SEGMENT_NUMBER    W_ERROR(0x000000B4)
+#define WERR_INVALID_ORDINAL   W_ERROR(0x000000B6)
+#define WERR_INVALID_FLAG_NUMBER       W_ERROR(0x000000BA)
+#define WERR_SEM_NOT_FOUND     W_ERROR(0x000000BB)
+#define WERR_INVALID_STARTING_CODESEG  W_ERROR(0x000000BC)
+#define WERR_INVALID_STACKSEG  W_ERROR(0x000000BD)
+#define WERR_INVALID_MODULETYPE        W_ERROR(0x000000BE)
+#define WERR_INVALID_EXE_SIGNATURE     W_ERROR(0x000000BF)
+#define WERR_EXE_MARKED_INVALID        W_ERROR(0x000000C0)
+#define WERR_BAD_EXE_FORMAT    W_ERROR(0x000000C1)
+#define WERR_ITERATED_DATA_EXCEEDS_64K W_ERROR(0x000000C2)
+#define WERR_INVALID_MINALLOCSIZE      W_ERROR(0x000000C3)
+#define WERR_DYNLINK_FROM_INVALID_RING W_ERROR(0x000000C4)
+#define WERR_IOPL_NOT_ENABLED  W_ERROR(0x000000C5)
+#define WERR_INVALID_SEGDPL    W_ERROR(0x000000C6)
+#define WERR_AUTODATASEG_EXCEEDS_64K   W_ERROR(0x000000C7)
+#define WERR_RING2SEG_MUST_BE_MOVABLE  W_ERROR(0x000000C8)
+#define WERR_RELOC_CHAIN_XEEDS_SEGLIM  W_ERROR(0x000000C9)
+#define WERR_INFLOOP_IN_RELOC_CHAIN    W_ERROR(0x000000CA)
+#define WERR_ENVVAR_NOT_FOUND  W_ERROR(0x000000CB)
+#define WERR_NO_SIGNAL_SENT    W_ERROR(0x000000CD)
+#define WERR_FILENAME_EXCED_RANGE      W_ERROR(0x000000CE)
+#define WERR_RING2_STACK_IN_USE        W_ERROR(0x000000CF)
+#define WERR_META_EXPANSION_TOO_LONG   W_ERROR(0x000000D0)
+#define WERR_INVALID_SIGNAL_NUMBER     W_ERROR(0x000000D1)
+#define WERR_THREAD_1_INACTIVE W_ERROR(0x000000D2)
+#define WERR_LOCKED    W_ERROR(0x000000D4)
+#define WERR_TOO_MANY_MODULES  W_ERROR(0x000000D6)
+#define WERR_NESTING_NOT_ALLOWED       W_ERROR(0x000000D7)
+#define WERR_EXE_MACHINE_TYPE_MISMATCH W_ERROR(0x000000D8)
+#define WERR_EXE_CANNOT_MODIFY_SIGNED_BINARY   W_ERROR(0x000000D9)
+#define WERR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY    W_ERROR(0x000000DA)
+#define WERR_FILE_CHECKED_OUT  W_ERROR(0x000000DC)
+#define WERR_CHECKOUT_REQUIRED W_ERROR(0x000000DD)
+#define WERR_BAD_FILE_TYPE     W_ERROR(0x000000DE)
+#define WERR_FILE_TOO_LARGE    W_ERROR(0x000000DF)
+#define WERR_FORMS_AUTH_REQUIRED       W_ERROR(0x000000E0)
+#define WERR_VIRUS_INFECTED    W_ERROR(0x000000E1)
+#define WERR_VIRUS_DELETED     W_ERROR(0x000000E2)
+#define WERR_PIPE_LOCAL        W_ERROR(0x000000E5)
+#define WERR_BAD_PIPE  W_ERROR(0x000000E6)
+#define WERR_PIPE_BUSY W_ERROR(0x000000E7)
+#define WERR_NO_DATA   W_ERROR(0x000000E8)
+#define WERR_PIPE_NOT_CONNECTED        W_ERROR(0x000000E9)
+#define WERR_VC_DISCONNECTED   W_ERROR(0x000000F0)
+#define WERR_INVALID_EA_NAME   W_ERROR(0x000000FE)
+#define WERR_EA_LIST_INCONSISTENT      W_ERROR(0x000000FF)
+#define WERR_WAIT_TIMEOUT      W_ERROR(0x00000102)
+#define WERR_CANNOT_COPY       W_ERROR(0x0000010A)
+#define WERR_DIRECTORY W_ERROR(0x0000010B)
+#define WERR_EAS_DIDNT_FIT     W_ERROR(0x00000113)
+#define WERR_EA_FILE_CORRUPT   W_ERROR(0x00000114)
+#define WERR_EA_TABLE_FULL     W_ERROR(0x00000115)
+#define WERR_INVALID_EA_HANDLE W_ERROR(0x00000116)
+#define WERR_EAS_NOT_SUPPORTED W_ERROR(0x0000011A)
+#define WERR_NOT_OWNER W_ERROR(0x00000120)
+#define WERR_TOO_MANY_POSTS    W_ERROR(0x0000012A)
+#define WERR_PARTIAL_COPY      W_ERROR(0x0000012B)
+#define WERR_OPLOCK_NOT_GRANTED        W_ERROR(0x0000012C)
+#define WERR_INVALID_OPLOCK_PROTOCOL   W_ERROR(0x0000012D)
+#define WERR_DISK_TOO_FRAGMENTED       W_ERROR(0x0000012E)
+#define WERR_DELETE_PENDING    W_ERROR(0x0000012F)
+#define WERR_MR_MID_NOT_FOUND  W_ERROR(0x0000013D)
+#define WERR_SCOPE_NOT_FOUND   W_ERROR(0x0000013E)
+#define WERR_FAIL_NOACTION_REBOOT      W_ERROR(0x0000015E)
+#define WERR_FAIL_SHUTDOWN     W_ERROR(0x0000015F)
+#define WERR_FAIL_RESTART      W_ERROR(0x00000160)
+#define WERR_MAX_SESSIONS_REACHED      W_ERROR(0x00000161)
+#define WERR_THREAD_MODE_ALREADY_BACKGROUND    W_ERROR(0x00000190)
+#define WERR_THREAD_MODE_NOT_BACKGROUND        W_ERROR(0x00000191)
+#define WERR_PROCESS_MODE_ALREADY_BACKGROUND   W_ERROR(0x00000192)
+#define WERR_PROCESS_MODE_NOT_BACKGROUND       W_ERROR(0x00000193)
+#define WERR_INVALID_ADDRESS   W_ERROR(0x000001E7)
+#define WERR_USER_PROFILE_LOAD W_ERROR(0x000001F4)
+#define WERR_ARITHMETIC_OVERFLOW       W_ERROR(0x00000216)
+#define WERR_PIPE_CONNECTED    W_ERROR(0x00000217)
+#define WERR_PIPE_LISTENING    W_ERROR(0x00000218)
+#define WERR_VERIFIER_STOP     W_ERROR(0x00000219)
+#define WERR_ABIOS_ERROR       W_ERROR(0x0000021A)
+#define WERR_WX86_WARNING      W_ERROR(0x0000021B)
+#define WERR_WX86_ERROR        W_ERROR(0x0000021C)
+#define WERR_TIMER_NOT_CANCELED        W_ERROR(0x0000021D)
+#define WERR_UNWIND    W_ERROR(0x0000021E)
+#define WERR_BAD_STACK W_ERROR(0x0000021F)
+#define WERR_INVALID_UNWIND_TARGET     W_ERROR(0x00000220)
+#define WERR_INVALID_PORT_ATTRIBUTES   W_ERROR(0x00000221)
+#define WERR_PORT_MESSAGE_TOO_LONG     W_ERROR(0x00000222)
+#define WERR_INVALID_QUOTA_LOWER       W_ERROR(0x00000223)
+#define WERR_DEVICE_ALREADY_ATTACHED   W_ERROR(0x00000224)
+#define WERR_INSTRUCTION_MISALIGNMENT  W_ERROR(0x00000225)
+#define WERR_PROFILING_NOT_STARTED     W_ERROR(0x00000226)
+#define WERR_PROFILING_NOT_STOPPED     W_ERROR(0x00000227)
+#define WERR_COULD_NOT_INTERPRET       W_ERROR(0x00000228)
+#define WERR_PROFILING_AT_LIMIT        W_ERROR(0x00000229)
+#define WERR_CANT_WAIT W_ERROR(0x0000022A)
+#define WERR_CANT_TERMINATE_SELF       W_ERROR(0x0000022B)
+#define WERR_UNEXPECTED_MM_CREATE_ERR  W_ERROR(0x0000022C)
+#define WERR_UNEXPECTED_MM_MAP_ERROR   W_ERROR(0x0000022D)
+#define WERR_UNEXPECTED_MM_EXTEND_ERR  W_ERROR(0x0000022E)
+#define WERR_BAD_FUNCTION_TABLE        W_ERROR(0x0000022F)
+#define WERR_NO_GUID_TRANSLATION       W_ERROR(0x00000230)
+#define WERR_INVALID_LDT_SIZE  W_ERROR(0x00000231)
+#define WERR_INVALID_LDT_OFFSET        W_ERROR(0x00000233)
+#define WERR_INVALID_LDT_DESCRIPTOR    W_ERROR(0x00000234)
+#define WERR_TOO_MANY_THREADS  W_ERROR(0x00000235)
+#define WERR_THREAD_NOT_IN_PROCESS     W_ERROR(0x00000236)
+#define WERR_PAGEFILE_QUOTA_EXCEEDED   W_ERROR(0x00000237)
+#define WERR_LOGON_SERVER_CONFLICT     W_ERROR(0x00000238)
+#define WERR_SYNCHRONIZATION_REQUIRED  W_ERROR(0x00000239)
+#define WERR_NET_OPEN_FAILED   W_ERROR(0x0000023A)
+#define WERR_IO_PRIVILEGE_FAILED       W_ERROR(0x0000023B)
+#define WERR_CONTROL_C_EXIT    W_ERROR(0x0000023C)
+#define WERR_MISSING_SYSTEMFILE        W_ERROR(0x0000023D)
+#define WERR_UNHANDLED_EXCEPTION       W_ERROR(0x0000023E)
+#define WERR_APP_INIT_FAILURE  W_ERROR(0x0000023F)
+#define WERR_PAGEFILE_CREATE_FAILED    W_ERROR(0x00000240)
+#define WERR_INVALID_IMAGE_HASH        W_ERROR(0x00000241)
+#define WERR_NO_PAGEFILE       W_ERROR(0x00000242)
+#define WERR_ILLEGAL_FLOAT_CONTEXT     W_ERROR(0x00000243)
+#define WERR_NO_EVENT_PAIR     W_ERROR(0x00000244)
+#define WERR_DOMAIN_CTRLR_CONFIG_ERROR W_ERROR(0x00000245)
+#define WERR_ILLEGAL_CHARACTER W_ERROR(0x00000246)
+#define WERR_UNDEFINED_CHARACTER       W_ERROR(0x00000247)
+#define WERR_FLOPPY_VOLUME     W_ERROR(0x00000248)
+#define WERR_BIOS_FAILED_TO_CONNECT_INTERRUPT  W_ERROR(0x00000249)
+#define WERR_BACKUP_CONTROLLER W_ERROR(0x0000024A)
+#define WERR_MUTANT_LIMIT_EXCEEDED     W_ERROR(0x0000024B)
+#define WERR_FS_DRIVER_REQUIRED        W_ERROR(0x0000024C)
+#define WERR_CANNOT_LOAD_REGISTRY_FILE W_ERROR(0x0000024D)
+#define WERR_DEBUG_ATTACH_FAILED       W_ERROR(0x0000024E)
+#define WERR_SYSTEM_PROCESS_TERMINATED W_ERROR(0x0000024F)
+#define WERR_DATA_NOT_ACCEPTED W_ERROR(0x00000250)
+#define WERR_VDM_HARD_ERROR    W_ERROR(0x00000251)
+#define WERR_DRIVER_CANCEL_TIMEOUT     W_ERROR(0x00000252)
+#define WERR_REPLY_MESSAGE_MISMATCH    W_ERROR(0x00000253)
+#define WERR_LOST_WRITEBEHIND_DATA     W_ERROR(0x00000254)
+#define WERR_CLIENT_SERVER_PARAMETERS_INVALID  W_ERROR(0x00000255)
+#define WERR_NOT_TINY_STREAM   W_ERROR(0x00000256)
+#define WERR_STACK_OVERFLOW_READ       W_ERROR(0x00000257)
+#define WERR_CONVERT_TO_LARGE  W_ERROR(0x00000258)
+#define WERR_FOUND_OUT_OF_SCOPE        W_ERROR(0x00000259)
+#define WERR_ALLOCATE_BUCKET   W_ERROR(0x0000025A)
+#define WERR_MARSHALL_OVERFLOW W_ERROR(0x0000025B)
+#define WERR_INVALID_VARIANT   W_ERROR(0x0000025C)
+#define WERR_BAD_COMPRESSION_BUFFER    W_ERROR(0x0000025D)
+#define WERR_AUDIT_FAILED      W_ERROR(0x0000025E)
+#define WERR_TIMER_RESOLUTION_NOT_SET  W_ERROR(0x0000025F)
+#define WERR_INSUFFICIENT_LOGON_INFO   W_ERROR(0x00000260)
+#define WERR_BAD_DLL_ENTRYPOINT        W_ERROR(0x00000261)
+#define WERR_BAD_SERVICE_ENTRYPOINT    W_ERROR(0x00000262)
+#define WERR_IP_ADDRESS_CONFLICT1      W_ERROR(0x00000263)
+#define WERR_IP_ADDRESS_CONFLICT2      W_ERROR(0x00000264)
+#define WERR_REGISTRY_QUOTA_LIMIT      W_ERROR(0x00000265)
+#define WERR_NO_CALLBACK_ACTIVE        W_ERROR(0x00000266)
+#define WERR_PWD_TOO_SHORT     W_ERROR(0x00000267)
+#define WERR_PWD_TOO_RECENT    W_ERROR(0x00000268)
+#define WERR_PWD_HISTORY_CONFLICT      W_ERROR(0x00000269)
+#define WERR_UNSUPPORTED_COMPRESSION   W_ERROR(0x0000026A)
+#define WERR_INVALID_HW_PROFILE        W_ERROR(0x0000026B)
+#define WERR_INVALID_PLUGPLAY_DEVICE_PATH      W_ERROR(0x0000026C)
+#define WERR_QUOTA_LIST_INCONSISTENT   W_ERROR(0x0000026D)
+#define WERR_EVALUATION_EXPIRATION     W_ERROR(0x0000026E)
+#define WERR_ILLEGAL_DLL_RELOCATION    W_ERROR(0x0000026F)
+#define WERR_DLL_INIT_FAILED_LOGOFF    W_ERROR(0x00000270)
+#define WERR_VALIDATE_CONTINUE W_ERROR(0x00000271)
+#define WERR_NO_MORE_MATCHES   W_ERROR(0x00000272)
+#define WERR_RANGE_LIST_CONFLICT       W_ERROR(0x00000273)
+#define WERR_SERVER_SID_MISMATCH       W_ERROR(0x00000274)
+#define WERR_CANT_ENABLE_DENY_ONLY     W_ERROR(0x00000275)
+#define WERR_FLOAT_MULTIPLE_FAULTS     W_ERROR(0x00000276)
+#define WERR_FLOAT_MULTIPLE_TRAPS      W_ERROR(0x00000277)
+#define WERR_NOINTERFACE       W_ERROR(0x00000278)
+#define WERR_DRIVER_FAILED_SLEEP       W_ERROR(0x00000279)
+#define WERR_CORRUPT_SYSTEM_FILE       W_ERROR(0x0000027A)
+#define WERR_COMMITMENT_MINIMUM        W_ERROR(0x0000027B)
+#define WERR_PNP_RESTART_ENUMERATION   W_ERROR(0x0000027C)
+#define WERR_SYSTEM_IMAGE_BAD_SIGNATURE        W_ERROR(0x0000027D)
+#define WERR_PNP_REBOOT_REQUIRED       W_ERROR(0x0000027E)
+#define WERR_INSUFFICIENT_POWER        W_ERROR(0x0000027F)
+#define WERR_MULTIPLE_FAULT_VIOLATION  W_ERROR(0x00000280)
+#define WERR_SYSTEM_SHUTDOWN   W_ERROR(0x00000281)
+#define WERR_PORT_NOT_SET      W_ERROR(0x00000282)
+#define WERR_DS_VERSION_CHECK_FAILURE  W_ERROR(0x00000283)
+#define WERR_RANGE_NOT_FOUND   W_ERROR(0x00000284)
+#define WERR_NOT_SAFE_MODE_DRIVER      W_ERROR(0x00000286)
+#define WERR_FAILED_DRIVER_ENTRY       W_ERROR(0x00000287)
+#define WERR_DEVICE_ENUMERATION_ERROR  W_ERROR(0x00000288)
+#define WERR_MOUNT_POINT_NOT_RESOLVED  W_ERROR(0x00000289)
+#define WERR_INVALID_DEVICE_OBJECT_PARAMETER   W_ERROR(0x0000028A)
+#define WERR_MCA_OCCURED       W_ERROR(0x0000028B)
+#define WERR_DRIVER_DATABASE_ERROR     W_ERROR(0x0000028C)
+#define WERR_SYSTEM_HIVE_TOO_LARGE     W_ERROR(0x0000028D)
+#define WERR_DRIVER_FAILED_PRIOR_UNLOAD        W_ERROR(0x0000028E)
+#define WERR_VOLSNAP_PREPARE_HIBERNATE W_ERROR(0x0000028F)
+#define WERR_HIBERNATION_FAILURE       W_ERROR(0x00000290)
+#define WERR_FILE_SYSTEM_LIMITATION    W_ERROR(0x00000299)
+#define WERR_ASSERTION_FAILURE W_ERROR(0x0000029C)
+#define WERR_ACPI_ERROR        W_ERROR(0x0000029D)
+#define WERR_WOW_ASSERTION     W_ERROR(0x0000029E)
+#define WERR_PNP_BAD_MPS_TABLE W_ERROR(0x0000029F)
+#define WERR_PNP_TRANSLATION_FAILED    W_ERROR(0x000002A0)
+#define WERR_PNP_IRQ_TRANSLATION_FAILED        W_ERROR(0x000002A1)
+#define WERR_PNP_INVALID_ID    W_ERROR(0x000002A2)
+#define WERR_WAKE_SYSTEM_DEBUGGER      W_ERROR(0x000002A3)
+#define WERR_HANDLES_CLOSED    W_ERROR(0x000002A4)
+#define WERR_EXTRANEOUS_INFORMATION    W_ERROR(0x000002A5)
+#define WERR_RXACT_COMMIT_NECESSARY    W_ERROR(0x000002A6)
+#define WERR_MEDIA_CHECK       W_ERROR(0x000002A7)
+#define WERR_GUID_SUBSTITUTION_MADE    W_ERROR(0x000002A8)
+#define WERR_STOPPED_ON_SYMLINK        W_ERROR(0x000002A9)
+#define WERR_LONGJUMP  W_ERROR(0x000002AA)
+#define WERR_PLUGPLAY_QUERY_VETOED     W_ERROR(0x000002AB)
+#define WERR_UNWIND_CONSOLIDATE        W_ERROR(0x000002AC)
+#define WERR_REGISTRY_HIVE_RECOVERED   W_ERROR(0x000002AD)
+#define WERR_DLL_MIGHT_BE_INSECURE     W_ERROR(0x000002AE)
+#define WERR_DLL_MIGHT_BE_INCOMPATIBLE W_ERROR(0x000002AF)
+#define WERR_DBG_EXCEPTION_NOT_HANDLED W_ERROR(0x000002B0)
+#define WERR_DBG_REPLY_LATER   W_ERROR(0x000002B1)
+#define WERR_DBG_UNABLE_TO_PROVIDE_HANDLE      W_ERROR(0x000002B2)
+#define WERR_DBG_TERMINATE_THREAD      W_ERROR(0x000002B3)
+#define WERR_DBG_TERMINATE_PROCESS     W_ERROR(0x000002B4)
+#define WERR_DBG_CONTROL_C     W_ERROR(0x000002B5)
+#define WERR_DBG_PRINTEXCEPTION_C      W_ERROR(0x000002B6)
+#define WERR_DBG_RIPEXCEPTION  W_ERROR(0x000002B7)
+#define WERR_DBG_CONTROL_BREAK W_ERROR(0x000002B8)
+#define WERR_DBG_COMMAND_EXCEPTION     W_ERROR(0x000002B9)
+#define WERR_OBJECT_NAME_EXISTS        W_ERROR(0x000002BA)
+#define WERR_THREAD_WAS_SUSPENDED      W_ERROR(0x000002BB)
+#define WERR_IMAGE_NOT_AT_BASE W_ERROR(0x000002BC)
+#define WERR_RXACT_STATE_CREATED       W_ERROR(0x000002BD)
+#define WERR_SEGMENT_NOTIFICATION      W_ERROR(0x000002BE)
+#define WERR_BAD_CURRENT_DIRECTORY     W_ERROR(0x000002BF)
+#define WERR_FT_READ_RECOVERY_FROM_BACKUP      W_ERROR(0x000002C0)
+#define WERR_FT_WRITE_RECOVERY W_ERROR(0x000002C1)
+#define WERR_IMAGE_MACHINE_TYPE_MISMATCH       W_ERROR(0x000002C2)
+#define WERR_RECEIVE_PARTIAL   W_ERROR(0x000002C3)
+#define WERR_RECEIVE_EXPEDITED W_ERROR(0x000002C4)
+#define WERR_RECEIVE_PARTIAL_EXPEDITED W_ERROR(0x000002C5)
+#define WERR_EVENT_DONE        W_ERROR(0x000002C6)
+#define WERR_EVENT_PENDING     W_ERROR(0x000002C7)
+#define WERR_CHECKING_FILE_SYSTEM      W_ERROR(0x000002C8)
+#define WERR_FATAL_APP_EXIT    W_ERROR(0x000002C9)
+#define WERR_PREDEFINED_HANDLE W_ERROR(0x000002CA)
+#define WERR_WAS_UNLOCKED      W_ERROR(0x000002CB)
+#define WERR_SERVICE_NOTIFICATION      W_ERROR(0x000002CC)
+#define WERR_WAS_LOCKED        W_ERROR(0x000002CD)
+#define WERR_LOG_HARD_ERROR    W_ERROR(0x000002CE)
+#define WERR_ALREADY_WIN32     W_ERROR(0x000002CF)
+#define WERR_IMAGE_MACHINE_TYPE_MISMATCH_EXE   W_ERROR(0x000002D0)
+#define WERR_NO_YIELD_PERFORMED        W_ERROR(0x000002D1)
+#define WERR_TIMER_RESUME_IGNORED      W_ERROR(0x000002D2)
+#define WERR_ARBITRATION_UNHANDLED     W_ERROR(0x000002D3)
+#define WERR_CARDBUS_NOT_SUPPORTED     W_ERROR(0x000002D4)
+#define WERR_MP_PROCESSOR_MISMATCH     W_ERROR(0x000002D5)
+#define WERR_HIBERNATED        W_ERROR(0x000002D6)
+#define WERR_RESUME_HIBERNATION        W_ERROR(0x000002D7)
+#define WERR_FIRMWARE_UPDATED  W_ERROR(0x000002D8)
+#define WERR_DRIVERS_LEAKING_LOCKED_PAGES      W_ERROR(0x000002D9)
+#define WERR_WAKE_SYSTEM       W_ERROR(0x000002DA)
+#define WERR_WAIT_1    W_ERROR(0x000002DB)
+#define WERR_WAIT_2    W_ERROR(0x000002DC)
+#define WERR_WAIT_3    W_ERROR(0x000002DD)
+#define WERR_WAIT_63   W_ERROR(0x000002DE)
+#define WERR_ABANDONED_WAIT_0  W_ERROR(0x000002DF)
+#define WERR_ABANDONED_WAIT_63 W_ERROR(0x000002E0)
+#define WERR_USER_APC  W_ERROR(0x000002E1)
+#define WERR_KERNEL_APC        W_ERROR(0x000002E2)
+#define WERR_ALERTED   W_ERROR(0x000002E3)
+#define WERR_ELEVATION_REQUIRED        W_ERROR(0x000002E4)
+#define WERR_REPARSE   W_ERROR(0x000002E5)
+#define WERR_OPLOCK_BREAK_IN_PROGRESS  W_ERROR(0x000002E6)
+#define WERR_VOLUME_MOUNTED    W_ERROR(0x000002E7)
+#define WERR_RXACT_COMMITTED   W_ERROR(0x000002E8)
+#define WERR_NOTIFY_CLEANUP    W_ERROR(0x000002E9)
+#define WERR_PRIMARY_TRANSPORT_CONNECT_FAILED  W_ERROR(0x000002EA)
+#define WERR_PAGE_FAULT_TRANSITION     W_ERROR(0x000002EB)
+#define WERR_PAGE_FAULT_DEMAND_ZERO    W_ERROR(0x000002EC)
+#define WERR_PAGE_FAULT_COPY_ON_WRITE  W_ERROR(0x000002ED)
+#define WERR_PAGE_FAULT_GUARD_PAGE     W_ERROR(0x000002EE)
+#define WERR_PAGE_FAULT_PAGING_FILE    W_ERROR(0x000002EF)
+#define WERR_CACHE_PAGE_LOCKED W_ERROR(0x000002F0)
+#define WERR_CRASH_DUMP        W_ERROR(0x000002F1)
+#define WERR_BUFFER_ALL_ZEROS  W_ERROR(0x000002F2)
+#define WERR_REPARSE_OBJECT    W_ERROR(0x000002F3)
+#define WERR_RESOURCE_REQUIREMENTS_CHANGED     W_ERROR(0x000002F4)
+#define WERR_TRANSLATION_COMPLETE      W_ERROR(0x000002F5)
+#define WERR_NOTHING_TO_TERMINATE      W_ERROR(0x000002F6)
+#define WERR_PROCESS_NOT_IN_JOB        W_ERROR(0x000002F7)
+#define WERR_PROCESS_IN_JOB    W_ERROR(0x000002F8)
+#define WERR_VOLSNAP_HIBERNATE_READY   W_ERROR(0x000002F9)
+#define WERR_FSFILTER_OP_COMPLETED_SUCCESSFULLY        W_ERROR(0x000002FA)
+#define WERR_INTERRUPT_VECTOR_ALREADY_CONNECTED        W_ERROR(0x000002FB)
+#define WERR_INTERRUPT_STILL_CONNECTED W_ERROR(0x000002FC)
+#define WERR_WAIT_FOR_OPLOCK   W_ERROR(0x000002FD)
+#define WERR_DBG_EXCEPTION_HANDLED     W_ERROR(0x000002FE)
+#define WERR_DBG_CONTINUE      W_ERROR(0x000002FF)
+#define WERR_CALLBACK_POP_STACK        W_ERROR(0x00000300)
+#define WERR_COMPRESSION_DISABLED      W_ERROR(0x00000301)
+#define WERR_CANTFETCHBACKWARDS        W_ERROR(0x00000302)
+#define WERR_CANTSCROLLBACKWARDS       W_ERROR(0x00000303)
+#define WERR_ROWSNOTRELEASED   W_ERROR(0x00000304)
+#define WERR_BAD_ACCESSOR_FLAGS        W_ERROR(0x00000305)
+#define WERR_ERRORS_ENCOUNTERED        W_ERROR(0x00000306)
+#define WERR_NOT_CAPABLE       W_ERROR(0x00000307)
+#define WERR_REQUEST_OUT_OF_SEQUENCE   W_ERROR(0x00000308)
+#define WERR_VERSION_PARSE_ERROR       W_ERROR(0x00000309)
+#define WERR_BADSTARTPOSITION  W_ERROR(0x0000030A)
+#define WERR_MEMORY_HARDWARE   W_ERROR(0x0000030B)
+#define WERR_DISK_REPAIR_DISABLED      W_ERROR(0x0000030C)
+#define WERR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE   W_ERROR(0x0000030D)
+#define WERR_SYSTEM_POWERSTATE_TRANSITION      W_ERROR(0x0000030E)
+#define WERR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION      W_ERROR(0x0000030F)
+#define WERR_MCA_EXCEPTION     W_ERROR(0x00000310)
+#define WERR_ACCESS_AUDIT_BY_POLICY    W_ERROR(0x00000311)
+#define WERR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY     W_ERROR(0x00000312)
+#define WERR_ABANDON_HIBERFILE W_ERROR(0x00000313)
+#define WERR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED        W_ERROR(0x00000314)
+#define WERR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR        W_ERROR(0x00000315)
+#define WERR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR    W_ERROR(0x00000316)
+#define WERR_EA_ACCESS_DENIED  W_ERROR(0x000003E2)
+#define WERR_OPERATION_ABORTED W_ERROR(0x000003E3)
+#define WERR_IO_INCOMPLETE     W_ERROR(0x000003E4)
+#define WERR_NOACCESS  W_ERROR(0x000003E6)
+#define WERR_SWAPERROR W_ERROR(0x000003E7)
+#define WERR_STACK_OVERFLOW    W_ERROR(0x000003E9)
+#define WERR_INVALID_MESSAGE   W_ERROR(0x000003EA)
+#define WERR_UNRECOGNIZED_VOLUME       W_ERROR(0x000003ED)
+#define WERR_FILE_INVALID      W_ERROR(0x000003EE)
+#define WERR_FULLSCREEN_MODE   W_ERROR(0x000003EF)
+#define WERR_NO_TOKEN  W_ERROR(0x000003F0)
+#define WERR_BADDB     W_ERROR(0x000003F1)
+#define WERR_BADKEY    W_ERROR(0x000003F2)
+#define WERR_CANTOPEN  W_ERROR(0x000003F3)
+#define WERR_CANTREAD  W_ERROR(0x000003F4)
+#define WERR_CANTWRITE W_ERROR(0x000003F5)
+#define WERR_REGISTRY_RECOVERED        W_ERROR(0x000003F6)
+#define WERR_REGISTRY_CORRUPT  W_ERROR(0x000003F7)
+#define WERR_REGISTRY_IO_FAILED        W_ERROR(0x000003F8)
+#define WERR_NOT_REGISTRY_FILE W_ERROR(0x000003F9)
+#define WERR_KEY_DELETED       W_ERROR(0x000003FA)
+#define WERR_NO_LOG_SPACE      W_ERROR(0x000003FB)
+#define WERR_KEY_HAS_CHILDREN  W_ERROR(0x000003FC)
+#define WERR_CHILD_MUST_BE_VOLATILE    W_ERROR(0x000003FD)
+#define WERR_NOTIFY_ENUM_DIR   W_ERROR(0x000003FE)
+#define WERR_DEPENDENT_SERVICES_RUNNING        W_ERROR(0x0000041B)
+#define WERR_SERVICE_REQUEST_TIMEOUT   W_ERROR(0x0000041D)
+#define WERR_SERVICE_NO_THREAD W_ERROR(0x0000041E)
+#define WERR_SERVICE_DATABASE_LOCKED   W_ERROR(0x0000041F)
+#define WERR_INVALID_SERVICE_ACCOUNT   W_ERROR(0x00000421)
+#define WERR_CIRCULAR_DEPENDENCY       W_ERROR(0x00000423)
+#define WERR_SERVICE_DOES_NOT_EXIST    W_ERROR(0x00000424)
+#define WERR_SERVICE_CANNOT_ACCEPT_CTRL        W_ERROR(0x00000425)
+#define WERR_SERVICE_NOT_ACTIVE        W_ERROR(0x00000426)
+#define WERR_FAILED_SERVICE_CONTROLLER_CONNECT W_ERROR(0x00000427)
+#define WERR_EXCEPTION_IN_SERVICE      W_ERROR(0x00000428)
+#define WERR_DATABASE_DOES_NOT_EXIST   W_ERROR(0x00000429)
+#define WERR_SERVICE_SPECIFIC_ERROR    W_ERROR(0x0000042A)
+#define WERR_PROCESS_ABORTED   W_ERROR(0x0000042B)
+#define WERR_SERVICE_DEPENDENCY_FAIL   W_ERROR(0x0000042C)
+#define WERR_SERVICE_LOGON_FAILED      W_ERROR(0x0000042D)
+#define WERR_SERVICE_START_HANG        W_ERROR(0x0000042E)
+#define WERR_INVALID_SERVICE_LOCK      W_ERROR(0x0000042F)
+#define WERR_ALREADY_RUNNING_LKG       W_ERROR(0x00000432)
+#define WERR_SERVICE_DEPENDENCY_DELETED        W_ERROR(0x00000433)
+#define WERR_BOOT_ALREADY_ACCEPTED     W_ERROR(0x00000434)
+#define WERR_DIFFERENT_SERVICE_ACCOUNT W_ERROR(0x00000437)
+#define WERR_CANNOT_DETECT_DRIVER_FAILURE      W_ERROR(0x00000438)
+#define WERR_CANNOT_DETECT_PROCESS_ABORT       W_ERROR(0x00000439)
+#define WERR_NO_RECOVERY_PROGRAM       W_ERROR(0x0000043A)
+#define WERR_SERVICE_NOT_IN_EXE        W_ERROR(0x0000043B)
+#define WERR_NOT_SAFEBOOT_SERVICE      W_ERROR(0x0000043C)
+#define WERR_END_OF_MEDIA      W_ERROR(0x0000044C)
+#define WERR_FILEMARK_DETECTED W_ERROR(0x0000044D)
+#define WERR_BEGINNING_OF_MEDIA        W_ERROR(0x0000044E)
+#define WERR_SETMARK_DETECTED  W_ERROR(0x0000044F)
+#define WERR_NO_DATA_DETECTED  W_ERROR(0x00000450)
+#define WERR_PARTITION_FAILURE W_ERROR(0x00000451)
+#define WERR_INVALID_BLOCK_LENGTH      W_ERROR(0x00000452)
+#define WERR_DEVICE_NOT_PARTITIONED    W_ERROR(0x00000453)
+#define WERR_UNABLE_TO_LOCK_MEDIA      W_ERROR(0x00000454)
+#define WERR_UNABLE_TO_UNLOAD_MEDIA    W_ERROR(0x00000455)
+#define WERR_MEDIA_CHANGED     W_ERROR(0x00000456)
+#define WERR_BUS_RESET W_ERROR(0x00000457)
+#define WERR_NO_MEDIA_IN_DRIVE W_ERROR(0x00000458)
+#define WERR_NO_UNICODE_TRANSLATION    W_ERROR(0x00000459)
+#define WERR_DLL_INIT_FAILED   W_ERROR(0x0000045A)
+#define WERR_SHUTDOWN_IN_PROGRESS      W_ERROR(0x0000045B)
+#define WERR_IO_DEVICE W_ERROR(0x0000045D)
+#define WERR_SERIAL_NO_DEVICE  W_ERROR(0x0000045E)
+#define WERR_IRQ_BUSY  W_ERROR(0x0000045F)
+#define WERR_MORE_WRITES       W_ERROR(0x00000460)
+#define WERR_COUNTER_TIMEOUT   W_ERROR(0x00000461)
+#define WERR_FLOPPY_ID_MARK_NOT_FOUND  W_ERROR(0x00000462)
+#define WERR_FLOPPY_WRONG_CYLINDER     W_ERROR(0x00000463)
+#define WERR_FLOPPY_UNKNOWN_ERROR      W_ERROR(0x00000464)
+#define WERR_FLOPPY_BAD_REGISTERS      W_ERROR(0x00000465)
+#define WERR_DISK_RECALIBRATE_FAILED   W_ERROR(0x00000466)
+#define WERR_DISK_OPERATION_FAILED     W_ERROR(0x00000467)
+#define WERR_DISK_RESET_FAILED W_ERROR(0x00000468)
+#define WERR_EOM_OVERFLOW      W_ERROR(0x00000469)
+#define WERR_NOT_ENOUGH_SERVER_MEMORY  W_ERROR(0x0000046A)
+#define WERR_POSSIBLE_DEADLOCK W_ERROR(0x0000046B)
+#define WERR_MAPPED_ALIGNMENT  W_ERROR(0x0000046C)
+#define WERR_SET_POWER_STATE_VETOED    W_ERROR(0x00000474)
+#define WERR_SET_POWER_STATE_FAILED    W_ERROR(0x00000475)
+#define WERR_TOO_MANY_LINKS    W_ERROR(0x00000476)
+#define WERR_OLD_WIN_VERSION   W_ERROR(0x0000047E)
+#define WERR_APP_WRONG_OS      W_ERROR(0x0000047F)
+#define WERR_SINGLE_INSTANCE_APP       W_ERROR(0x00000480)
+#define WERR_RMODE_APP W_ERROR(0x00000481)
+#define WERR_INVALID_DLL       W_ERROR(0x00000482)
+#define WERR_NO_ASSOCIATION    W_ERROR(0x00000483)
+#define WERR_DDE_FAIL  W_ERROR(0x00000484)
+#define WERR_DLL_NOT_FOUND     W_ERROR(0x00000485)
+#define WERR_NO_MORE_USER_HANDLES      W_ERROR(0x00000486)
+#define WERR_MESSAGE_SYNC_ONLY W_ERROR(0x00000487)
+#define WERR_SOURCE_ELEMENT_EMPTY      W_ERROR(0x00000488)
+#define WERR_DESTINATION_ELEMENT_FULL  W_ERROR(0x00000489)
+#define WERR_ILLEGAL_ELEMENT_ADDRESS   W_ERROR(0x0000048A)
+#define WERR_MAGAZINE_NOT_PRESENT      W_ERROR(0x0000048B)
+#define WERR_DEVICE_REINITIALIZATION_NEEDED    W_ERROR(0x0000048C)
+#define WERR_DEVICE_REQUIRES_CLEANING  W_ERROR(0x0000048D)
+#define WERR_DEVICE_DOOR_OPEN  W_ERROR(0x0000048E)
+#define WERR_NO_MATCH  W_ERROR(0x00000491)
+#define WERR_SET_NOT_FOUND     W_ERROR(0x00000492)
+#define WERR_POINT_NOT_FOUND   W_ERROR(0x00000493)
+#define WERR_NO_TRACKING_SERVICE       W_ERROR(0x00000494)
+#define WERR_NO_VOLUME_ID      W_ERROR(0x00000495)
+#define WERR_UNABLE_TO_REMOVE_REPLACED W_ERROR(0x00000497)
+#define WERR_UNABLE_TO_MOVE_REPLACEMENT        W_ERROR(0x00000498)
+#define WERR_UNABLE_TO_MOVE_REPLACEMENT_2      W_ERROR(0x00000499)
+#define WERR_JOURNAL_DELETE_IN_PROGRESS        W_ERROR(0x0000049A)
+#define WERR_JOURNAL_NOT_ACTIVE        W_ERROR(0x0000049B)
+#define WERR_POTENTIAL_FILE_FOUND      W_ERROR(0x0000049C)
+#define WERR_JOURNAL_ENTRY_DELETED     W_ERROR(0x0000049D)
+#define WERR_SHUTDOWN_IS_SCHEDULED     W_ERROR(0x000004A6)
+#define WERR_SHUTDOWN_USERS_LOGGED_ON  W_ERROR(0x000004A7)
+#define WERR_BAD_DEVICE        W_ERROR(0x000004B0)
+#define WERR_CONNECTION_UNAVAIL        W_ERROR(0x000004B1)
+#define WERR_DEVICE_ALREADY_REMEMBERED W_ERROR(0x000004B2)
+#define WERR_NO_NET_OR_BAD_PATH        W_ERROR(0x000004B3)
+#define WERR_BAD_PROVIDER      W_ERROR(0x000004B4)
+#define WERR_CANNOT_OPEN_PROFILE       W_ERROR(0x000004B5)
+#define WERR_BAD_PROFILE       W_ERROR(0x000004B6)
+#define WERR_NOT_CONTAINER     W_ERROR(0x000004B7)
+#define WERR_EXTENDED_ERROR    W_ERROR(0x000004B8)
+#define WERR_INVALID_GROUPNAME W_ERROR(0x000004B9)
+#define WERR_INVALID_EVENTNAME W_ERROR(0x000004BB)
+#define WERR_INVALID_SERVICENAME       W_ERROR(0x000004BD)
+#define WERR_INVALID_NETNAME   W_ERROR(0x000004BE)
+#define WERR_INVALID_SHARENAME W_ERROR(0x000004BF)
+#define WERR_INVALID_PASSWORDNAME      W_ERROR(0x000004C0)
+#define WERR_INVALID_MESSAGENAME       W_ERROR(0x000004C1)
+#define WERR_INVALID_MESSAGEDEST       W_ERROR(0x000004C2)
+#define WERR_SESSION_CREDENTIAL_CONFLICT       W_ERROR(0x000004C3)
+#define WERR_REMOTE_SESSION_LIMIT_EXCEEDED     W_ERROR(0x000004C4)
+#define WERR_DUP_DOMAINNAME    W_ERROR(0x000004C5)
+#define WERR_NO_NETWORK        W_ERROR(0x000004C6)
+#define WERR_CANCELLED W_ERROR(0x000004C7)
+#define WERR_USER_MAPPED_FILE  W_ERROR(0x000004C8)
+#define WERR_CONNECTION_REFUSED        W_ERROR(0x000004C9)
+#define WERR_GRACEFUL_DISCONNECT       W_ERROR(0x000004CA)
+#define WERR_ADDRESS_ALREADY_ASSOCIATED        W_ERROR(0x000004CB)
+#define WERR_ADDRESS_NOT_ASSOCIATED    W_ERROR(0x000004CC)
+#define WERR_CONNECTION_INVALID        W_ERROR(0x000004CD)
+#define WERR_CONNECTION_ACTIVE W_ERROR(0x000004CE)
+#define WERR_NETWORK_UNREACHABLE       W_ERROR(0x000004CF)
+#define WERR_HOST_UNREACHABLE  W_ERROR(0x000004D0)
+#define WERR_PROTOCOL_UNREACHABLE      W_ERROR(0x000004D1)
+#define WERR_PORT_UNREACHABLE  W_ERROR(0x000004D2)
+#define WERR_REQUEST_ABORTED   W_ERROR(0x000004D3)
+#define WERR_CONNECTION_ABORTED        W_ERROR(0x000004D4)
+#define WERR_RETRY     W_ERROR(0x000004D5)
+#define WERR_CONNECTION_COUNT_LIMIT    W_ERROR(0x000004D6)
+#define WERR_LOGIN_TIME_RESTRICTION    W_ERROR(0x000004D7)
+#define WERR_LOGIN_WKSTA_RESTRICTION   W_ERROR(0x000004D8)
+#define WERR_INCORRECT_ADDRESS W_ERROR(0x000004D9)
+#define WERR_ALREADY_REGISTERED        W_ERROR(0x000004DA)
+#define WERR_SERVICE_NOT_FOUND W_ERROR(0x000004DB)
+#define WERR_NOT_LOGGED_ON     W_ERROR(0x000004DD)
+#define WERR_CONTINUE  W_ERROR(0x000004DE)
+#define WERR_ALREADY_INITIALIZED       W_ERROR(0x000004DF)
+#define WERR_NO_MORE_DEVICES   W_ERROR(0x000004E0)
+#define WERR_NO_SUCH_SITE      W_ERROR(0x000004E1)
+#define WERR_DOMAIN_CONTROLLER_EXISTS  W_ERROR(0x000004E2)
+#define WERR_ONLY_IF_CONNECTED W_ERROR(0x000004E3)
+#define WERR_OVERRIDE_NOCHANGES        W_ERROR(0x000004E4)
+#define WERR_BAD_USER_PROFILE  W_ERROR(0x000004E5)
+#define WERR_NOT_SUPPORTED_ON_SBS      W_ERROR(0x000004E6)
+#define WERR_SERVER_SHUTDOWN_IN_PROGRESS       W_ERROR(0x000004E7)
+#define WERR_HOST_DOWN W_ERROR(0x000004E8)
+#define WERR_NON_ACCOUNT_SID   W_ERROR(0x000004E9)
+#define WERR_NON_DOMAIN_SID    W_ERROR(0x000004EA)
+#define WERR_APPHELP_BLOCK     W_ERROR(0x000004EB)
+#define WERR_ACCESS_DISABLED_BY_POLICY W_ERROR(0x000004EC)
+#define WERR_REG_NAT_CONSUMPTION       W_ERROR(0x000004ED)
+#define WERR_CSCSHARE_OFFLINE  W_ERROR(0x000004EE)
+#define WERR_PKINIT_FAILURE    W_ERROR(0x000004EF)
+#define WERR_SMARTCARD_SUBSYSTEM_FAILURE       W_ERROR(0x000004F0)
+#define WERR_DOWNGRADE_DETECTED        W_ERROR(0x000004F1)
+#define WERR_CALLBACK_SUPPLIED_INVALID_DATA    W_ERROR(0x000004F9)
+#define WERR_SYNC_FOREGROUND_REFRESH_REQUIRED  W_ERROR(0x000004FA)
+#define WERR_DRIVER_BLOCKED    W_ERROR(0x000004FB)
+#define WERR_INVALID_IMPORT_OF_NON_DLL W_ERROR(0x000004FC)
+#define WERR_ACCESS_DISABLED_WEBBLADE  W_ERROR(0x000004FD)
+#define WERR_ACCESS_DISABLED_WEBBLADE_TAMPER   W_ERROR(0x000004FE)
+#define WERR_RECOVERY_FAILURE  W_ERROR(0x000004FF)
+#define WERR_ALREADY_FIBER     W_ERROR(0x00000500)
+#define WERR_ALREADY_THREAD    W_ERROR(0x00000501)
+#define WERR_STACK_BUFFER_OVERRUN      W_ERROR(0x00000502)
+#define WERR_PARAMETER_QUOTA_EXCEEDED  W_ERROR(0x00000503)
+#define WERR_DEBUGGER_INACTIVE W_ERROR(0x00000504)
+#define WERR_DELAY_LOAD_FAILED W_ERROR(0x00000505)
+#define WERR_VDM_DISALLOWED    W_ERROR(0x00000506)
+#define WERR_UNIDENTIFIED_ERROR        W_ERROR(0x00000507)
+#define WERR_BEYOND_VDL        W_ERROR(0x00000509)
+#define WERR_INCOMPATIBLE_SERVICE_SID_TYPE     W_ERROR(0x0000050A)
+#define WERR_DRIVER_PROCESS_TERMINATED W_ERROR(0x0000050B)
+#define WERR_IMPLEMENTATION_LIMIT      W_ERROR(0x0000050C)
+#define WERR_PROCESS_IS_PROTECTED      W_ERROR(0x0000050D)
+#define WERR_SERVICE_NOTIFY_CLIENT_LAGGING     W_ERROR(0x0000050E)
+#define WERR_DISK_QUOTA_EXCEEDED       W_ERROR(0x0000050F)
+#define WERR_CONTENT_BLOCKED   W_ERROR(0x00000510)
+#define WERR_INCOMPATIBLE_SERVICE_PRIVILEGE    W_ERROR(0x00000511)
+#define WERR_INVALID_LABEL     W_ERROR(0x00000513)
+#define WERR_NOT_ALL_ASSIGNED  W_ERROR(0x00000514)
+#define WERR_SOME_NOT_MAPPED   W_ERROR(0x00000515)
+#define WERR_NO_QUOTAS_FOR_ACCOUNT     W_ERROR(0x00000516)
+#define WERR_LOCAL_USER_SESSION_KEY    W_ERROR(0x00000517)
+#define WERR_NULL_LM_PASSWORD  W_ERROR(0x00000518)
+#define WERR_NO_IMPERSONATION_TOKEN    W_ERROR(0x0000051D)
+#define WERR_CANT_DISABLE_MANDATORY    W_ERROR(0x0000051E)
+#define WERR_INVALID_ACCOUNT_NAME      W_ERROR(0x00000523)
+#define WERR_USER_EXISTS       W_ERROR(0x00000524)
+#define WERR_MEMBER_NOT_IN_GROUP       W_ERROR(0x00000529)
+#define WERR_LAST_ADMIN        W_ERROR(0x0000052A)
+#define WERR_ILL_FORMED_PASSWORD       W_ERROR(0x0000052C)
+#define WERR_ACCOUNT_RESTRICTION       W_ERROR(0x0000052F)
+#define WERR_INVALID_LOGON_HOURS       W_ERROR(0x00000530)
+#define WERR_INVALID_WORKSTATION       W_ERROR(0x00000531)
+#define WERR_PASSWORD_EXPIRED  W_ERROR(0x00000532)
+#define WERR_ACCOUNT_DISABLED  W_ERROR(0x00000533)
+#define WERR_TOO_MANY_LUIDS_REQUESTED  W_ERROR(0x00000535)
+#define WERR_LUIDS_EXHAUSTED   W_ERROR(0x00000536)
+#define WERR_INVALID_SUB_AUTHORITY     W_ERROR(0x00000537)
+#define WERR_INVALID_ACL       W_ERROR(0x00000538)
+#define WERR_INVALID_SID       W_ERROR(0x00000539)
+#define WERR_INVALID_SECURITY_DESCR    W_ERROR(0x0000053A)
+#define WERR_BAD_INHERITANCE_ACL       W_ERROR(0x0000053C)
+#define WERR_SERVER_DISABLED   W_ERROR(0x0000053D)
+#define WERR_SERVER_NOT_DISABLED       W_ERROR(0x0000053E)
+#define WERR_INVALID_ID_AUTHORITY      W_ERROR(0x0000053F)
+#define WERR_ALLOTTED_SPACE_EXCEEDED   W_ERROR(0x00000540)
+#define WERR_INVALID_GROUP_ATTRIBUTES  W_ERROR(0x00000541)
+#define WERR_BAD_IMPERSONATION_LEVEL   W_ERROR(0x00000542)
+#define WERR_CANT_OPEN_ANONYMOUS       W_ERROR(0x00000543)
+#define WERR_BAD_VALIDATION_CLASS      W_ERROR(0x00000544)
+#define WERR_BAD_TOKEN_TYPE    W_ERROR(0x00000545)
+#define WERR_NO_SECURITY_ON_OBJECT     W_ERROR(0x00000546)
+#define WERR_CANT_ACCESS_DOMAIN_INFO   W_ERROR(0x00000547)
+#define WERR_INVALID_SERVER_STATE      W_ERROR(0x00000548)
+#define WERR_DOMAIN_EXISTS     W_ERROR(0x0000054C)
+#define WERR_DOMAIN_LIMIT_EXCEEDED     W_ERROR(0x0000054D)
+#define WERR_INTERNAL_DB_CORRUPTION    W_ERROR(0x0000054E)
+#define WERR_INTERNAL_ERROR    W_ERROR(0x0000054F)
+#define WERR_GENERIC_NOT_MAPPED        W_ERROR(0x00000550)
+#define WERR_BAD_DESCRIPTOR_FORMAT     W_ERROR(0x00000551)
+#define WERR_NOT_LOGON_PROCESS W_ERROR(0x00000552)
+#define WERR_LOGON_SESSION_EXISTS      W_ERROR(0x00000553)
+#define WERR_NO_SUCH_PACKAGE   W_ERROR(0x00000554)
+#define WERR_BAD_LOGON_SESSION_STATE   W_ERROR(0x00000555)
+#define WERR_LOGON_SESSION_COLLISION   W_ERROR(0x00000556)
+#define WERR_INVALID_LOGON_TYPE        W_ERROR(0x00000557)
+#define WERR_CANNOT_IMPERSONATE        W_ERROR(0x00000558)
+#define WERR_RXACT_INVALID_STATE       W_ERROR(0x00000559)
+#define WERR_RXACT_COMMIT_FAILURE      W_ERROR(0x0000055A)
+#define WERR_SPECIAL_GROUP     W_ERROR(0x0000055C)
+#define WERR_SPECIAL_USER      W_ERROR(0x0000055D)
+#define WERR_MEMBERS_PRIMARY_GROUP     W_ERROR(0x0000055E)
+#define WERR_TOKEN_ALREADY_IN_USE      W_ERROR(0x0000055F)
+#define WERR_MEMBER_NOT_IN_ALIAS       W_ERROR(0x00000561)
+#define WERR_LOGON_NOT_GRANTED W_ERROR(0x00000564)
+#define WERR_TOO_MANY_SECRETS  W_ERROR(0x00000565)
+#define WERR_SECRET_TOO_LONG   W_ERROR(0x00000566)
+#define WERR_INTERNAL_DB_ERROR W_ERROR(0x00000567)
+#define WERR_TOO_MANY_CONTEXT_IDS      W_ERROR(0x00000568)
+#define WERR_LOGON_TYPE_NOT_GRANTED    W_ERROR(0x00000569)
+#define WERR_NT_CROSS_ENCRYPTION_REQUIRED      W_ERROR(0x0000056A)
+#define WERR_NO_SUCH_MEMBER    W_ERROR(0x0000056B)
+#define WERR_INVALID_MEMBER    W_ERROR(0x0000056C)
+#define WERR_TOO_MANY_SIDS     W_ERROR(0x0000056D)
+#define WERR_LM_CROSS_ENCRYPTION_REQUIRED      W_ERROR(0x0000056E)
+#define WERR_NO_INHERITANCE    W_ERROR(0x0000056F)
+#define WERR_FILE_CORRUPT      W_ERROR(0x00000570)
+#define WERR_DISK_CORRUPT      W_ERROR(0x00000571)
+#define WERR_NO_USER_SESSION_KEY       W_ERROR(0x00000572)
+#define WERR_LICENSE_QUOTA_EXCEEDED    W_ERROR(0x00000573)
+#define WERR_WRONG_TARGET_NAME W_ERROR(0x00000574)
+#define WERR_MUTUAL_AUTH_FAILED        W_ERROR(0x00000575)
+#define WERR_CURRENT_DOMAIN_NOT_ALLOWED        W_ERROR(0x00000577)
+#define WERR_INVALID_WINDOW_HANDLE     W_ERROR(0x00000578)
+#define WERR_INVALID_MENU_HANDLE       W_ERROR(0x00000579)
+#define WERR_INVALID_CURSOR_HANDLE     W_ERROR(0x0000057A)
+#define WERR_INVALID_ACCEL_HANDLE      W_ERROR(0x0000057B)
+#define WERR_INVALID_HOOK_HANDLE       W_ERROR(0x0000057C)
+#define WERR_INVALID_DWP_HANDLE        W_ERROR(0x0000057D)
+#define WERR_TLW_WITH_WSCHILD  W_ERROR(0x0000057E)
+#define WERR_CANNOT_FIND_WND_CLASS     W_ERROR(0x0000057F)
+#define WERR_WINDOW_OF_OTHER_THREAD    W_ERROR(0x00000580)
+#define WERR_HOTKEY_ALREADY_REGISTERED W_ERROR(0x00000581)
+#define WERR_CLASS_ALREADY_EXISTS      W_ERROR(0x00000582)
+#define WERR_CLASS_DOES_NOT_EXIST      W_ERROR(0x00000583)
+#define WERR_CLASS_HAS_WINDOWS W_ERROR(0x00000584)
+#define WERR_INVALID_INDEX     W_ERROR(0x00000585)
+#define WERR_INVALID_ICON_HANDLE       W_ERROR(0x00000586)
+#define WERR_PRIVATE_DIALOG_INDEX      W_ERROR(0x00000587)
+#define WERR_LISTBOX_ID_NOT_FOUND      W_ERROR(0x00000588)
+#define WERR_NO_WILDCARD_CHARACTERS    W_ERROR(0x00000589)
+#define WERR_CLIPBOARD_NOT_OPEN        W_ERROR(0x0000058A)
+#define WERR_HOTKEY_NOT_REGISTERED     W_ERROR(0x0000058B)
+#define WERR_WINDOW_NOT_DIALOG W_ERROR(0x0000058C)
+#define WERR_CONTROL_ID_NOT_FOUND      W_ERROR(0x0000058D)
+#define WERR_INVALID_COMBOBOX_MESSAGE  W_ERROR(0x0000058E)
+#define WERR_WINDOW_NOT_COMBOBOX       W_ERROR(0x0000058F)
+#define WERR_INVALID_EDIT_HEIGHT       W_ERROR(0x00000590)
+#define WERR_DC_NOT_FOUND      W_ERROR(0x00000591)
+#define WERR_INVALID_HOOK_FILTER       W_ERROR(0x00000592)
+#define WERR_INVALID_FILTER_PROC       W_ERROR(0x00000593)
+#define WERR_HOOK_NEEDS_HMOD   W_ERROR(0x00000594)
+#define WERR_GLOBAL_ONLY_HOOK  W_ERROR(0x00000595)
+#define WERR_JOURNAL_HOOK_SET  W_ERROR(0x00000596)
+#define WERR_HOOK_NOT_INSTALLED        W_ERROR(0x00000597)
+#define WERR_INVALID_LB_MESSAGE        W_ERROR(0x00000598)
+#define WERR_SETCOUNT_ON_BAD_LB        W_ERROR(0x00000599)
+#define WERR_LB_WITHOUT_TABSTOPS       W_ERROR(0x0000059A)
+#define WERR_DESTROY_OBJECT_OF_OTHER_THREAD    W_ERROR(0x0000059B)
+#define WERR_CHILD_WINDOW_MENU W_ERROR(0x0000059C)
+#define WERR_NO_SYSTEM_MENU    W_ERROR(0x0000059D)
+#define WERR_INVALID_MSGBOX_STYLE      W_ERROR(0x0000059E)
+#define WERR_INVALID_SPI_VALUE W_ERROR(0x0000059F)
+#define WERR_SCREEN_ALREADY_LOCKED     W_ERROR(0x000005A0)
+#define WERR_HWNDS_HAVE_DIFF_PARENT    W_ERROR(0x000005A1)
+#define WERR_NOT_CHILD_WINDOW  W_ERROR(0x000005A2)
+#define WERR_INVALID_GW_COMMAND        W_ERROR(0x000005A3)
+#define WERR_INVALID_THREAD_ID W_ERROR(0x000005A4)
+#define WERR_NON_MDICHILD_WINDOW       W_ERROR(0x000005A5)
+#define WERR_POPUP_ALREADY_ACTIVE      W_ERROR(0x000005A6)
+#define WERR_NO_SCROLLBARS     W_ERROR(0x000005A7)
+#define WERR_INVALID_SCROLLBAR_RANGE   W_ERROR(0x000005A8)
+#define WERR_INVALID_SHOWWIN_COMMAND   W_ERROR(0x000005A9)
+#define WERR_NONPAGED_SYSTEM_RESOURCES W_ERROR(0x000005AB)
+#define WERR_PAGED_SYSTEM_RESOURCES    W_ERROR(0x000005AC)
+#define WERR_WORKING_SET_QUOTA W_ERROR(0x000005AD)
+#define WERR_PAGEFILE_QUOTA    W_ERROR(0x000005AE)
+#define WERR_COMMITMENT_LIMIT  W_ERROR(0x000005AF)
+#define WERR_MENU_ITEM_NOT_FOUND       W_ERROR(0x000005B0)
+#define WERR_INVALID_KEYBOARD_HANDLE   W_ERROR(0x000005B1)
+#define WERR_HOOK_TYPE_NOT_ALLOWED     W_ERROR(0x000005B2)
+#define WERR_REQUIRES_INTERACTIVE_WINDOWSTATION        W_ERROR(0x000005B3)
+#define WERR_TIMEOUT   W_ERROR(0x000005B4)
+#define WERR_INVALID_MONITOR_HANDLE    W_ERROR(0x000005B5)
+#define WERR_INCORRECT_SIZE    W_ERROR(0x000005B6)
+#define WERR_SYMLINK_CLASS_DISABLED    W_ERROR(0x000005B7)
+#define WERR_SYMLINK_NOT_SUPPORTED     W_ERROR(0x000005B8)
+#define WERR_EVENTLOG_CANT_START       W_ERROR(0x000005DD)
+#define WERR_LOG_FILE_FULL     W_ERROR(0x000005DE)
+#define WERR_EVENTLOG_FILE_CHANGED     W_ERROR(0x000005DF)
+#define WERR_INVALID_TASK_NAME W_ERROR(0x0000060E)
+#define WERR_INVALID_TASK_INDEX        W_ERROR(0x0000060F)
+#define WERR_THREAD_ALREADY_IN_TASK    W_ERROR(0x00000610)
+#define WERR_INSTALL_SERVICE_FAILURE   W_ERROR(0x00000641)
+#define WERR_INSTALL_USEREXIT  W_ERROR(0x00000642)
+#define WERR_INSTALL_FAILURE   W_ERROR(0x00000643)
+#define WERR_INSTALL_SUSPEND   W_ERROR(0x00000644)
+#define WERR_UNKNOWN_PRODUCT   W_ERROR(0x00000645)
+#define WERR_UNKNOWN_FEATURE   W_ERROR(0x00000646)
+#define WERR_UNKNOWN_COMPONENT W_ERROR(0x00000647)
+#define WERR_UNKNOWN_PROPERTY  W_ERROR(0x00000648)
+#define WERR_INVALID_HANDLE_STATE      W_ERROR(0x00000649)
+#define WERR_BAD_CONFIGURATION W_ERROR(0x0000064A)
+#define WERR_INDEX_ABSENT      W_ERROR(0x0000064B)
+#define WERR_INSTALL_SOURCE_ABSENT     W_ERROR(0x0000064C)
+#define WERR_INSTALL_PACKAGE_VERSION   W_ERROR(0x0000064D)
+#define WERR_PRODUCT_UNINSTALLED       W_ERROR(0x0000064E)
+#define WERR_BAD_QUERY_SYNTAX  W_ERROR(0x0000064F)
+#define WERR_INVALID_FIELD     W_ERROR(0x00000650)
+#define WERR_DEVICE_REMOVED    W_ERROR(0x00000651)
+#define WERR_INSTALL_ALREADY_RUNNING   W_ERROR(0x00000652)
+#define WERR_INSTALL_PACKAGE_OPEN_FAILED       W_ERROR(0x00000653)
+#define WERR_INSTALL_PACKAGE_INVALID   W_ERROR(0x00000654)
+#define WERR_INSTALL_UI_FAILURE        W_ERROR(0x00000655)
+#define WERR_INSTALL_LOG_FAILURE       W_ERROR(0x00000656)
+#define WERR_INSTALL_LANGUAGE_UNSUPPORTED      W_ERROR(0x00000657)
+#define WERR_INSTALL_TRANSFORM_FAILURE W_ERROR(0x00000658)
+#define WERR_INSTALL_PACKAGE_REJECTED  W_ERROR(0x00000659)
+#define WERR_FUNCTION_NOT_CALLED       W_ERROR(0x0000065A)
+#define WERR_FUNCTION_FAILED   W_ERROR(0x0000065B)
+#define WERR_INVALID_TABLE     W_ERROR(0x0000065C)
+#define WERR_DATATYPE_MISMATCH W_ERROR(0x0000065D)
+#define WERR_UNSUPPORTED_TYPE  W_ERROR(0x0000065E)
+#define WERR_CREATE_FAILED     W_ERROR(0x0000065F)
+#define WERR_INSTALL_TEMP_UNWRITABLE   W_ERROR(0x00000660)
+#define WERR_INSTALL_PLATFORM_UNSUPPORTED      W_ERROR(0x00000661)
+#define WERR_INSTALL_NOTUSED   W_ERROR(0x00000662)
+#define WERR_PATCH_PACKAGE_OPEN_FAILED W_ERROR(0x00000663)
+#define WERR_PATCH_PACKAGE_INVALID     W_ERROR(0x00000664)
+#define WERR_PATCH_PACKAGE_UNSUPPORTED W_ERROR(0x00000665)
+#define WERR_PRODUCT_VERSION   W_ERROR(0x00000666)
+#define WERR_INVALID_COMMAND_LINE      W_ERROR(0x00000667)
+#define WERR_INSTALL_REMOTE_DISALLOWED W_ERROR(0x00000668)
+#define WERR_SUCCESS_REBOOT_INITIATED  W_ERROR(0x00000669)
+#define WERR_PATCH_TARGET_NOT_FOUND    W_ERROR(0x0000066A)
+#define WERR_PATCH_PACKAGE_REJECTED    W_ERROR(0x0000066B)
+#define WERR_INSTALL_TRANSFORM_REJECTED        W_ERROR(0x0000066C)
+#define WERR_INSTALL_REMOTE_PROHIBITED W_ERROR(0x0000066D)
+#define WERR_PATCH_REMOVAL_UNSUPPORTED W_ERROR(0x0000066E)
+#define WERR_UNKNOWN_PATCH     W_ERROR(0x0000066F)
+#define WERR_PATCH_NO_SEQUENCE W_ERROR(0x00000670)
+#define WERR_PATCH_REMOVAL_DISALLOWED  W_ERROR(0x00000671)
+#define WERR_INVALID_PATCH_XML W_ERROR(0x00000672)
+#define WERR_PATCH_MANAGED_ADVERTISED_PRODUCT  W_ERROR(0x00000673)
+#define WERR_INSTALL_SERVICE_SAFEBOOT  W_ERROR(0x00000674)
+#define WERR_RPC_S_INVALID_STRING_BINDING      W_ERROR(0x000006A4)
+#define WERR_RPC_S_WRONG_KIND_OF_BINDING       W_ERROR(0x000006A5)
+#define WERR_RPC_S_INVALID_BINDING     W_ERROR(0x000006A6)
+#define WERR_RPC_S_PROTSEQ_NOT_SUPPORTED       W_ERROR(0x000006A7)
+#define WERR_RPC_S_INVALID_RPC_PROTSEQ W_ERROR(0x000006A8)
+#define WERR_RPC_S_INVALID_STRING_UUID W_ERROR(0x000006A9)
+#define WERR_RPC_S_INVALID_ENDPOINT_FORMAT     W_ERROR(0x000006AA)
+#define WERR_RPC_S_INVALID_NET_ADDR    W_ERROR(0x000006AB)
+#define WERR_RPC_S_NO_ENDPOINT_FOUND   W_ERROR(0x000006AC)
+#define WERR_RPC_S_INVALID_TIMEOUT     W_ERROR(0x000006AD)
+#define WERR_RPC_S_OBJECT_NOT_FOUND    W_ERROR(0x000006AE)
+#define WERR_RPC_S_ALREADY_REGISTERED  W_ERROR(0x000006AF)
+#define WERR_RPC_S_TYPE_ALREADY_REGISTERED     W_ERROR(0x000006B0)
+#define WERR_RPC_S_ALREADY_LISTENING   W_ERROR(0x000006B1)
+#define WERR_RPC_S_NO_PROTSEQS_REGISTERED      W_ERROR(0x000006B2)
+#define WERR_RPC_S_NOT_LISTENING       W_ERROR(0x000006B3)
+#define WERR_RPC_S_UNKNOWN_MGR_TYPE    W_ERROR(0x000006B4)
+#define WERR_RPC_S_UNKNOWN_IF  W_ERROR(0x000006B5)
+#define WERR_RPC_S_NO_BINDINGS W_ERROR(0x000006B6)
+#define WERR_RPC_S_NO_PROTSEQS W_ERROR(0x000006B7)
+#define WERR_RPC_S_CANT_CREATE_ENDPOINT        W_ERROR(0x000006B8)
+#define WERR_RPC_S_OUT_OF_RESOURCES    W_ERROR(0x000006B9)
+#define WERR_RPC_S_SERVER_UNAVAILABLE  W_ERROR(0x000006BA)
+#define WERR_RPC_S_SERVER_TOO_BUSY     W_ERROR(0x000006BB)
+#define WERR_RPC_S_INVALID_NETWORK_OPTIONS     W_ERROR(0x000006BC)
+#define WERR_RPC_S_NO_CALL_ACTIVE      W_ERROR(0x000006BD)
+#define WERR_RPC_S_CALL_FAILED W_ERROR(0x000006BE)
+#define WERR_RPC_S_CALL_FAILED_DNE     W_ERROR(0x000006BF)
+#define WERR_RPC_S_PROTOCOL_ERROR      W_ERROR(0x000006C0)
+#define WERR_RPC_S_PROXY_ACCESS_DENIED W_ERROR(0x000006C1)
+#define WERR_RPC_S_UNSUPPORTED_TRANS_SYN       W_ERROR(0x000006C2)
+#define WERR_RPC_S_UNSUPPORTED_TYPE    W_ERROR(0x000006C4)
+#define WERR_RPC_S_INVALID_TAG W_ERROR(0x000006C5)
+#define WERR_RPC_S_INVALID_BOUND       W_ERROR(0x000006C6)
+#define WERR_RPC_S_NO_ENTRY_NAME       W_ERROR(0x000006C7)
+#define WERR_RPC_S_INVALID_NAME_SYNTAX W_ERROR(0x000006C8)
+#define WERR_RPC_S_UNSUPPORTED_NAME_SYNTAX     W_ERROR(0x000006C9)
+#define WERR_RPC_S_UUID_NO_ADDRESS     W_ERROR(0x000006CB)
+#define WERR_RPC_S_DUPLICATE_ENDPOINT  W_ERROR(0x000006CC)
+#define WERR_RPC_S_UNKNOWN_AUTHN_TYPE  W_ERROR(0x000006CD)
+#define WERR_RPC_S_MAX_CALLS_TOO_SMALL W_ERROR(0x000006CE)
+#define WERR_RPC_S_STRING_TOO_LONG     W_ERROR(0x000006CF)
+#define WERR_RPC_S_PROTSEQ_NOT_FOUND   W_ERROR(0x000006D0)
+#define WERR_RPC_S_PROCNUM_OUT_OF_RANGE        W_ERROR(0x000006D1)
+#define WERR_RPC_S_BINDING_HAS_NO_AUTH W_ERROR(0x000006D2)
+#define WERR_RPC_S_UNKNOWN_AUTHN_SERVICE       W_ERROR(0x000006D3)
+#define WERR_RPC_S_UNKNOWN_AUTHN_LEVEL W_ERROR(0x000006D4)
+#define WERR_RPC_S_INVALID_AUTH_IDENTITY       W_ERROR(0x000006D5)
+#define WERR_RPC_S_UNKNOWN_AUTHZ_SERVICE       W_ERROR(0x000006D6)
+#define WERR_EPT_S_INVALID_ENTRY       W_ERROR(0x000006D7)
+#define WERR_EPT_S_CANT_PERFORM_OP     W_ERROR(0x000006D8)
+#define WERR_EPT_S_NOT_REGISTERED      W_ERROR(0x000006D9)
+#define WERR_RPC_S_NOTHING_TO_EXPORT   W_ERROR(0x000006DA)
+#define WERR_RPC_S_INCOMPLETE_NAME     W_ERROR(0x000006DB)
+#define WERR_RPC_S_INVALID_VERS_OPTION W_ERROR(0x000006DC)
+#define WERR_RPC_S_NO_MORE_MEMBERS     W_ERROR(0x000006DD)
+#define WERR_RPC_S_NOT_ALL_OBJS_UNEXPORTED     W_ERROR(0x000006DE)
+#define WERR_RPC_S_INTERFACE_NOT_FOUND W_ERROR(0x000006DF)
+#define WERR_RPC_S_ENTRY_ALREADY_EXISTS        W_ERROR(0x000006E0)
+#define WERR_RPC_S_ENTRY_NOT_FOUND     W_ERROR(0x000006E1)
+#define WERR_RPC_S_NAME_SERVICE_UNAVAILABLE    W_ERROR(0x000006E2)
+#define WERR_RPC_S_INVALID_NAF_ID      W_ERROR(0x000006E3)
+#define WERR_RPC_S_CANNOT_SUPPORT      W_ERROR(0x000006E4)
+#define WERR_RPC_S_NO_CONTEXT_AVAILABLE        W_ERROR(0x000006E5)
+#define WERR_RPC_S_INTERNAL_ERROR      W_ERROR(0x000006E6)
+#define WERR_RPC_S_ZERO_DIVIDE W_ERROR(0x000006E7)
+#define WERR_RPC_S_ADDRESS_ERROR       W_ERROR(0x000006E8)
+#define WERR_RPC_S_FP_DIV_ZERO W_ERROR(0x000006E9)
+#define WERR_RPC_S_FP_UNDERFLOW        W_ERROR(0x000006EA)
+#define WERR_RPC_S_FP_OVERFLOW W_ERROR(0x000006EB)
+#define WERR_RPC_X_NO_MORE_ENTRIES     W_ERROR(0x000006EC)
+#define WERR_RPC_X_SS_CHAR_TRANS_OPEN_FAIL     W_ERROR(0x000006ED)
+#define WERR_RPC_X_SS_CHAR_TRANS_SHORT_FILE    W_ERROR(0x000006EE)
+#define WERR_RPC_X_SS_IN_NULL_CONTEXT  W_ERROR(0x000006EF)
+#define WERR_RPC_X_SS_CONTEXT_DAMAGED  W_ERROR(0x000006F1)
+#define WERR_RPC_X_SS_HANDLES_MISMATCH W_ERROR(0x000006F2)
+#define WERR_RPC_X_SS_CANNOT_GET_CALL_HANDLE   W_ERROR(0x000006F3)
+#define WERR_RPC_X_NULL_REF_POINTER    W_ERROR(0x000006F4)
+#define WERR_RPC_X_ENUM_VALUE_OUT_OF_RANGE     W_ERROR(0x000006F5)
+#define WERR_RPC_X_BYTE_COUNT_TOO_SMALL        W_ERROR(0x000006F6)
+#define WERR_RPC_X_BAD_STUB_DATA       W_ERROR(0x000006F7)
+#define WERR_UNRECOGNIZED_MEDIA        W_ERROR(0x000006F9)
+#define WERR_NO_TRUST_LSA_SECRET       W_ERROR(0x000006FA)
+#define WERR_TRUSTED_DOMAIN_FAILURE    W_ERROR(0x000006FC)
+#define WERR_TRUSTED_RELATIONSHIP_FAILURE      W_ERROR(0x000006FD)
+#define WERR_TRUST_FAILURE     W_ERROR(0x000006FE)
+#define WERR_RPC_S_CALL_IN_PROGRESS    W_ERROR(0x000006FF)
+#define WERR_NETLOGON_NOT_STARTED      W_ERROR(0x00000700)
+#define WERR_ACCOUNT_EXPIRED   W_ERROR(0x00000701)
+#define WERR_REDIRECTOR_HAS_OPEN_HANDLES       W_ERROR(0x00000702)
+#define WERR_RPC_S_NO_MORE_BINDINGS    W_ERROR(0x0000070E)
+#define WERR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT W_ERROR(0x0000070F)
+#define WERR_NOLOGON_WORKSTATION_TRUST_ACCOUNT W_ERROR(0x00000710)
+#define WERR_NOLOGON_SERVER_TRUST_ACCOUNT      W_ERROR(0x00000711)
+#define WERR_DOMAIN_TRUST_INCONSISTENT W_ERROR(0x00000712)
+#define WERR_SERVER_HAS_OPEN_HANDLES   W_ERROR(0x00000713)
+#define WERR_RESOURCE_DATA_NOT_FOUND   W_ERROR(0x00000714)
+#define WERR_RESOURCE_TYPE_NOT_FOUND   W_ERROR(0x00000715)
+#define WERR_RESOURCE_NAME_NOT_FOUND   W_ERROR(0x00000716)
+#define WERR_RESOURCE_LANG_NOT_FOUND   W_ERROR(0x00000717)
+#define WERR_NOT_ENOUGH_QUOTA  W_ERROR(0x00000718)
+#define WERR_RPC_S_NO_INTERFACES       W_ERROR(0x00000719)
+#define WERR_RPC_S_CALL_CANCELLED      W_ERROR(0x0000071A)
+#define WERR_RPC_S_BINDING_INCOMPLETE  W_ERROR(0x0000071B)
+#define WERR_RPC_S_COMM_FAILURE        W_ERROR(0x0000071C)
+#define WERR_RPC_S_UNSUPPORTED_AUTHN_LEVEL     W_ERROR(0x0000071D)
+#define WERR_RPC_S_NO_PRINC_NAME       W_ERROR(0x0000071E)
+#define WERR_RPC_S_NOT_RPC_ERROR       W_ERROR(0x0000071F)
+#define WERR_RPC_S_UUID_LOCAL_ONLY     W_ERROR(0x00000720)
+#define WERR_RPC_S_SEC_PKG_ERROR       W_ERROR(0x00000721)
+#define WERR_RPC_S_NOT_CANCELLED       W_ERROR(0x00000722)
+#define WERR_RPC_X_INVALID_ES_ACTION   W_ERROR(0x00000723)
+#define WERR_RPC_X_WRONG_ES_VERSION    W_ERROR(0x00000724)
+#define WERR_RPC_X_WRONG_STUB_VERSION  W_ERROR(0x00000725)
+#define WERR_RPC_X_INVALID_PIPE_OBJECT W_ERROR(0x00000726)
+#define WERR_RPC_X_WRONG_PIPE_ORDER    W_ERROR(0x00000727)
+#define WERR_RPC_X_WRONG_PIPE_VERSION  W_ERROR(0x00000728)
+#define WERR_RPC_S_GROUP_MEMBER_NOT_FOUND      W_ERROR(0x0000076A)
+#define WERR_EPT_S_CANT_CREATE W_ERROR(0x0000076B)
+#define WERR_RPC_S_INVALID_OBJECT      W_ERROR(0x0000076C)
+#define WERR_INVALID_TIME      W_ERROR(0x0000076D)
+#define WERR_ALREADY_WAITING   W_ERROR(0x00000770)
+#define WERR_PRINTER_DELETED   W_ERROR(0x00000771)
+#define WERR_INVALID_PRINTER_STATE     W_ERROR(0x00000772)
+#define WERR_OR_INVALID_OXID   W_ERROR(0x00000776)
+#define WERR_OR_INVALID_OID    W_ERROR(0x00000777)
+#define WERR_OR_INVALID_SET    W_ERROR(0x00000778)
+#define WERR_RPC_S_SEND_INCOMPLETE     W_ERROR(0x00000779)
+#define WERR_RPC_S_INVALID_ASYNC_HANDLE        W_ERROR(0x0000077A)
+#define WERR_RPC_S_INVALID_ASYNC_CALL  W_ERROR(0x0000077B)
+#define WERR_RPC_X_PIPE_CLOSED W_ERROR(0x0000077C)
+#define WERR_RPC_X_PIPE_DISCIPLINE_ERROR       W_ERROR(0x0000077D)
+#define WERR_RPC_X_PIPE_EMPTY  W_ERROR(0x0000077E)
+#define WERR_NO_SITENAME       W_ERROR(0x0000077F)
+#define WERR_CANT_ACCESS_FILE  W_ERROR(0x00000780)
+#define WERR_CANT_RESOLVE_FILENAME     W_ERROR(0x00000781)
+#define WERR_RPC_S_ENTRY_TYPE_MISMATCH W_ERROR(0x00000782)
+#define WERR_RPC_S_NOT_ALL_OBJS_EXPORTED       W_ERROR(0x00000783)
+#define WERR_RPC_S_INTERFACE_NOT_EXPORTED      W_ERROR(0x00000784)
+#define WERR_RPC_S_PROFILE_NOT_ADDED   W_ERROR(0x00000785)
+#define WERR_RPC_S_PRF_ELT_NOT_ADDED   W_ERROR(0x00000786)
+#define WERR_RPC_S_PRF_ELT_NOT_REMOVED W_ERROR(0x00000787)
+#define WERR_RPC_S_GRP_ELT_NOT_ADDED   W_ERROR(0x00000788)
+#define WERR_RPC_S_GRP_ELT_NOT_REMOVED W_ERROR(0x00000789)
+#define WERR_KM_DRIVER_BLOCKED W_ERROR(0x0000078A)
+#define WERR_CONTEXT_EXPIRED   W_ERROR(0x0000078B)
+#define WERR_PER_USER_TRUST_QUOTA_EXCEEDED     W_ERROR(0x0000078C)
+#define WERR_ALL_USER_TRUST_QUOTA_EXCEEDED     W_ERROR(0x0000078D)
+#define WERR_USER_DELETE_TRUST_QUOTA_EXCEEDED  W_ERROR(0x0000078E)
+#define WERR_AUTHENTICATION_FIREWALL_FAILED    W_ERROR(0x0000078F)
+#define WERR_REMOTE_PRINT_CONNECTIONS_BLOCKED  W_ERROR(0x00000790)
+#define WERR_INVALID_PIXEL_FORMAT      W_ERROR(0x000007D0)
+#define WERR_BAD_DRIVER        W_ERROR(0x000007D1)
+#define WERR_INVALID_WINDOW_STYLE      W_ERROR(0x000007D2)
+#define WERR_METAFILE_NOT_SUPPORTED    W_ERROR(0x000007D3)
+#define WERR_TRANSFORM_NOT_SUPPORTED   W_ERROR(0x000007D4)
+#define WERR_CLIPPING_NOT_SUPPORTED    W_ERROR(0x000007D5)
+#define WERR_INVALID_CMM       W_ERROR(0x000007DA)
+#define WERR_INVALID_PROFILE   W_ERROR(0x000007DB)
+#define WERR_TAG_NOT_FOUND     W_ERROR(0x000007DC)
+#define WERR_TAG_NOT_PRESENT   W_ERROR(0x000007DD)
+#define WERR_DUPLICATE_TAG     W_ERROR(0x000007DE)
+#define WERR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE        W_ERROR(0x000007DF)
+#define WERR_PROFILE_NOT_FOUND W_ERROR(0x000007E0)
+#define WERR_INVALID_COLORSPACE        W_ERROR(0x000007E1)
+#define WERR_ICM_NOT_ENABLED   W_ERROR(0x000007E2)
+#define WERR_DELETING_ICM_XFORM        W_ERROR(0x000007E3)
+#define WERR_INVALID_TRANSFORM W_ERROR(0x000007E4)
+#define WERR_COLORSPACE_MISMATCH       W_ERROR(0x000007E5)
+#define WERR_INVALID_COLORINDEX        W_ERROR(0x000007E6)
+#define WERR_PROFILE_DOES_NOT_MATCH_DEVICE     W_ERROR(0x000007E7)
+#define WERR_NERR_NETNOTSTARTED        W_ERROR(0x00000836)
+#define WERR_NERR_UNKNOWNSERVER        W_ERROR(0x00000837)
+#define WERR_NERR_SHAREMEM     W_ERROR(0x00000838)
+#define WERR_NERR_NONETWORKRESOURCE    W_ERROR(0x00000839)
+#define WERR_NERR_REMOTEONLY   W_ERROR(0x0000083A)
+#define WERR_NERR_DEVNOTREDIRECTED     W_ERROR(0x0000083B)
+#define WERR_CONNECTED_OTHER_PASSWORD  W_ERROR(0x0000083C)
+#define WERR_CONNECTED_OTHER_PASSWORD_DEFAULT  W_ERROR(0x0000083D)
+#define WERR_NERR_SERVERNOTSTARTED     W_ERROR(0x00000842)
+#define WERR_NERR_ITEMNOTFOUND W_ERROR(0x00000843)
+#define WERR_NERR_UNKNOWNDEVDIR        W_ERROR(0x00000844)
+#define WERR_NERR_REDIRECTEDPATH       W_ERROR(0x00000845)
+#define WERR_NERR_DUPLICATESHARE       W_ERROR(0x00000846)
+#define WERR_NERR_NOROOM       W_ERROR(0x00000847)
+#define WERR_NERR_TOOMANYITEMS W_ERROR(0x00000849)
+#define WERR_NERR_INVALIDMAXUSERS      W_ERROR(0x0000084A)
+#define WERR_NERR_BUFTOOSMALL  W_ERROR(0x0000084B)
+#define WERR_NERR_REMOTEERR    W_ERROR(0x0000084F)
+#define WERR_NERR_LANMANINIERROR       W_ERROR(0x00000853)
+#define WERR_NERR_NETWORKERROR W_ERROR(0x00000858)
+#define WERR_NERR_WKSTAINCONSISTENTSTATE       W_ERROR(0x00000859)
+#define WERR_NERR_WKSTANOTSTARTED      W_ERROR(0x0000085A)
+#define WERR_NERR_BROWSERNOTSTARTED    W_ERROR(0x0000085B)
+#define WERR_NERR_INTERNALERROR        W_ERROR(0x0000085C)
+#define WERR_NERR_BADTRANSACTCONFIG    W_ERROR(0x0000085D)
+#define WERR_NERR_INVALIDAPI   W_ERROR(0x0000085E)
+#define WERR_NERR_BADEVENTNAME W_ERROR(0x0000085F)
+#define WERR_NERR_DUPNAMEREBOOT        W_ERROR(0x00000860)
+#define WERR_NERR_CFGCOMPNOTFOUND      W_ERROR(0x00000862)
+#define WERR_NERR_CFGPARAMNOTFOUND     W_ERROR(0x00000863)
+#define WERR_NERR_LINETOOLONG  W_ERROR(0x00000865)
+#define WERR_NERR_QNOTFOUND    W_ERROR(0x00000866)
+#define WERR_NERR_JOBNOTFOUND  W_ERROR(0x00000867)
+#define WERR_NERR_DESTNOTFOUND W_ERROR(0x00000868)
+#define WERR_NERR_DESTEXISTS   W_ERROR(0x00000869)
+#define WERR_NERR_QEXISTS      W_ERROR(0x0000086A)
+#define WERR_NERR_QNOROOM      W_ERROR(0x0000086B)
+#define WERR_NERR_JOBNOROOM    W_ERROR(0x0000086C)
+#define WERR_NERR_DESTNOROOM   W_ERROR(0x0000086D)
+#define WERR_NERR_DESTIDLE     W_ERROR(0x0000086E)
+#define WERR_NERR_DESTINVALIDOP        W_ERROR(0x0000086F)
+#define WERR_NERR_PROCNORESPOND        W_ERROR(0x00000870)
+#define WERR_NERR_SPOOLERNOTLOADED     W_ERROR(0x00000871)
+#define WERR_NERR_DESTINVALIDSTATE     W_ERROR(0x00000872)
+#define WERR_NERR_QINVALIDSTATE        W_ERROR(0x00000873)
+#define WERR_NERR_JOBINVALIDSTATE      W_ERROR(0x00000874)
+#define WERR_NERR_SPOOLNOMEMORY        W_ERROR(0x00000875)
+#define WERR_NERR_DRIVERNOTFOUND       W_ERROR(0x00000876)
+#define WERR_NERR_DATATYPEINVALID      W_ERROR(0x00000877)
+#define WERR_NERR_PROCNOTFOUND W_ERROR(0x00000878)
+#define WERR_NERR_SERVICETABLELOCKED   W_ERROR(0x00000884)
+#define WERR_NERR_SERVICETABLEFULL     W_ERROR(0x00000885)
+#define WERR_NERR_SERVICEINSTALLED     W_ERROR(0x00000886)
+#define WERR_NERR_SERVICEENTRYLOCKED   W_ERROR(0x00000887)
+#define WERR_NERR_SERVICENOTINSTALLED  W_ERROR(0x00000888)
+#define WERR_NERR_BADSERVICENAME       W_ERROR(0x00000889)
+#define WERR_NERR_SERVICECTLTIMEOUT    W_ERROR(0x0000088A)
+#define WERR_NERR_SERVICECTLBUSY       W_ERROR(0x0000088B)
+#define WERR_NERR_BADSERVICEPROGNAME   W_ERROR(0x0000088C)
+#define WERR_NERR_SERVICENOTCTRL       W_ERROR(0x0000088D)
+#define WERR_NERR_SERVICEKILLPROC      W_ERROR(0x0000088E)
+#define WERR_NERR_SERVICECTLNOTVALID   W_ERROR(0x0000088F)
+#define WERR_NERR_NOTINDISPATCHTBL     W_ERROR(0x00000890)
+#define WERR_NERR_BADCONTROLRECV       W_ERROR(0x00000891)
+#define WERR_NERR_SERVICENOTSTARTING   W_ERROR(0x00000892)
+#define WERR_NERR_ALREADYLOGGEDON      W_ERROR(0x00000898)
+#define WERR_NERR_NOTLOGGEDON  W_ERROR(0x00000899)
+#define WERR_NERR_BADUSERNAME  W_ERROR(0x0000089A)
+#define WERR_NERR_BADPASSWORD  W_ERROR(0x0000089B)
+#define WERR_NERR_UNABLETOADDNAME_W    W_ERROR(0x0000089C)
+#define WERR_NERR_UNABLETOADDNAME_F    W_ERROR(0x0000089D)
+#define WERR_NERR_UNABLETODELNAME_W    W_ERROR(0x0000089E)
+#define WERR_NERR_UNABLETODELNAME_F    W_ERROR(0x0000089F)
+#define WERR_NERR_LOGONSPAUSED W_ERROR(0x000008A1)
+#define WERR_NERR_LOGONSERVERCONFLICT  W_ERROR(0x000008A2)
+#define WERR_NERR_LOGONNOUSERPATH      W_ERROR(0x000008A3)
+#define WERR_NERR_LOGONSCRIPTERROR     W_ERROR(0x000008A4)
+#define WERR_NERR_STANDALONELOGON      W_ERROR(0x000008A6)
+#define WERR_NERR_LOGONSERVERNOTFOUND  W_ERROR(0x000008A7)
+#define WERR_NERR_LOGONDOMAINEXISTS    W_ERROR(0x000008A8)
+#define WERR_NERR_NONVALIDATEDLOGON    W_ERROR(0x000008A9)
+#define WERR_NERR_ACFNOTFOUND  W_ERROR(0x000008AB)
+#define WERR_NERR_GROUPNOTFOUND        W_ERROR(0x000008AC)
+#define WERR_NERR_USERNOTFOUND W_ERROR(0x000008AD)
+#define WERR_NERR_RESOURCENOTFOUND     W_ERROR(0x000008AE)
+#define WERR_NERR_GROUPEXISTS  W_ERROR(0x000008AF)
+#define WERR_NERR_USEREXISTS   W_ERROR(0x000008B0)
+#define WERR_NERR_RESOURCEEXISTS       W_ERROR(0x000008B1)
+#define WERR_NERR_NOTPRIMARY   W_ERROR(0x000008B2)
+#define WERR_NERR_ACFNOTLOADED W_ERROR(0x000008B3)
+#define WERR_NERR_ACFNOROOM    W_ERROR(0x000008B4)
+#define WERR_NERR_ACFFILEIOFAIL        W_ERROR(0x000008B5)
+#define WERR_NERR_ACFTOOMANYLISTS      W_ERROR(0x000008B6)
+#define WERR_NERR_USERLOGON    W_ERROR(0x000008B7)
+#define WERR_NERR_ACFNOPARENT  W_ERROR(0x000008B8)
+#define WERR_NERR_CANNOTGROWSEGMENT    W_ERROR(0x000008B9)
+#define WERR_NERR_SPEGROUPOP   W_ERROR(0x000008BA)
+#define WERR_NERR_NOTINCACHE   W_ERROR(0x000008BB)
+#define WERR_NERR_USERINGROUP  W_ERROR(0x000008BC)
+#define WERR_NERR_USERNOTINGROUP       W_ERROR(0x000008BD)
+#define WERR_NERR_ACCOUNTUNDEFINED     W_ERROR(0x000008BE)
+#define WERR_NERR_ACCOUNTEXPIRED       W_ERROR(0x000008BF)
+#define WERR_NERR_INVALIDWORKSTATION   W_ERROR(0x000008C0)
+#define WERR_NERR_INVALIDLOGONHOURS    W_ERROR(0x000008C1)
+#define WERR_NERR_PASSWORDEXPIRED      W_ERROR(0x000008C2)
+#define WERR_NERR_PASSWORDCANTCHANGE   W_ERROR(0x000008C3)
+#define WERR_NERR_PASSWORDHISTCONFLICT W_ERROR(0x000008C4)
+#define WERR_NERR_PASSWORDTOOSHORT     W_ERROR(0x000008C5)
+#define WERR_NERR_PASSWORDTOORECENT    W_ERROR(0x000008C6)
+#define WERR_NERR_INVALIDDATABASE      W_ERROR(0x000008C7)
+#define WERR_NERR_DATABASEUPTODATE     W_ERROR(0x000008C8)
+#define WERR_NERR_SYNCREQUIRED W_ERROR(0x000008C9)
+#define WERR_NERR_USENOTFOUND  W_ERROR(0x000008CA)
+#define WERR_NERR_BADASGTYPE   W_ERROR(0x000008CB)
+#define WERR_NERR_DEVICEISSHARED       W_ERROR(0x000008CC)
+#define WERR_NERR_NOCOMPUTERNAME       W_ERROR(0x000008DE)
+#define WERR_NERR_MSGALREADYSTARTED    W_ERROR(0x000008DF)
+#define WERR_NERR_MSGINITFAILED        W_ERROR(0x000008E0)
+#define WERR_NERR_NAMENOTFOUND W_ERROR(0x000008E1)
+#define WERR_NERR_ALREADYFORWARDED     W_ERROR(0x000008E2)
+#define WERR_NERR_ADDFORWARDED W_ERROR(0x000008E3)
+#define WERR_NERR_ALREADYEXISTS        W_ERROR(0x000008E4)
+#define WERR_NERR_TOOMANYNAMES W_ERROR(0x000008E5)
+#define WERR_NERR_DELCOMPUTERNAME      W_ERROR(0x000008E6)
+#define WERR_NERR_LOCALFORWARD W_ERROR(0x000008E7)
+#define WERR_NERR_GRPMSGPROCESSOR      W_ERROR(0x000008E8)
+#define WERR_NERR_PAUSEDREMOTE W_ERROR(0x000008E9)
+#define WERR_NERR_BADRECEIVE   W_ERROR(0x000008EA)
+#define WERR_NERR_NAMEINUSE    W_ERROR(0x000008EB)
+#define WERR_NERR_MSGNOTSTARTED        W_ERROR(0x000008EC)
+#define WERR_NERR_NOTLOCALNAME W_ERROR(0x000008ED)
+#define WERR_NERR_NOFORWARDNAME        W_ERROR(0x000008EE)
+#define WERR_NERR_REMOTEFULL   W_ERROR(0x000008EF)
+#define WERR_NERR_NAMENOTFORWARDED     W_ERROR(0x000008F0)
+#define WERR_NERR_TRUNCATEDBROADCAST   W_ERROR(0x000008F1)
+#define WERR_NERR_INVALIDDEVICE        W_ERROR(0x000008F6)
+#define WERR_NERR_WRITEFAULT   W_ERROR(0x000008F7)
+#define WERR_NERR_DUPLICATENAME        W_ERROR(0x000008F9)
+#define WERR_NERR_DELETELATER  W_ERROR(0x000008FA)
+#define WERR_NERR_INCOMPLETEDEL        W_ERROR(0x000008FB)
+#define WERR_NERR_MULTIPLENETS W_ERROR(0x000008FC)
+#define WERR_NERR_NETNAMENOTFOUND      W_ERROR(0x00000906)
+#define WERR_NERR_DEVICENOTSHARED      W_ERROR(0x00000907)
+#define WERR_NERR_CLIENTNAMENOTFOUND   W_ERROR(0x00000908)
+#define WERR_NERR_FILEIDNOTFOUND       W_ERROR(0x0000090A)
+#define WERR_NERR_EXECFAILURE  W_ERROR(0x0000090B)
+#define WERR_NERR_TMPFILE      W_ERROR(0x0000090C)
+#define WERR_NERR_TOOMUCHDATA  W_ERROR(0x0000090D)
+#define WERR_NERR_DEVICESHARECONFLICT  W_ERROR(0x0000090E)
+#define WERR_NERR_BROWSERTABLEINCOMPLETE       W_ERROR(0x0000090F)
+#define WERR_NERR_NOTLOCALDOMAIN       W_ERROR(0x00000910)
+#define WERR_NERR_ISDFSSHARE   W_ERROR(0x00000911)
+#define WERR_NERR_DEVINVALIDOPCODE     W_ERROR(0x0000091B)
+#define WERR_NERR_DEVNOTFOUND  W_ERROR(0x0000091C)
+#define WERR_NERR_DEVNOTOPEN   W_ERROR(0x0000091D)
+#define WERR_NERR_BADQUEUEDEVSTRING    W_ERROR(0x0000091E)
+#define WERR_NERR_BADQUEUEPRIORITY     W_ERROR(0x0000091F)
+#define WERR_NERR_NOCOMMDEVS   W_ERROR(0x00000921)
+#define WERR_NERR_QUEUENOTFOUND        W_ERROR(0x00000922)
+#define WERR_NERR_BADDEVSTRING W_ERROR(0x00000924)
+#define WERR_NERR_BADDEV       W_ERROR(0x00000925)
+#define WERR_NERR_INUSEBYSPOOLER       W_ERROR(0x00000926)
+#define WERR_NERR_COMMDEVINUSE W_ERROR(0x00000927)
+#define WERR_NERR_INVALIDCOMPUTER      W_ERROR(0x0000092F)
+#define WERR_NERR_MAXLENEXCEEDED       W_ERROR(0x00000932)
+#define WERR_NERR_BADCOMPONENT W_ERROR(0x00000934)
+#define WERR_NERR_CANTTYPE     W_ERROR(0x00000935)
+#define WERR_NERR_TOOMANYENTRIES       W_ERROR(0x0000093A)
+#define WERR_NERR_PROFILEFILETOOBIG    W_ERROR(0x00000942)
+#define WERR_NERR_PROFILEOFFSET        W_ERROR(0x00000943)
+#define WERR_NERR_PROFILECLEANUP       W_ERROR(0x00000944)
+#define WERR_NERR_PROFILEUNKNOWNCMD    W_ERROR(0x00000945)
+#define WERR_NERR_PROFILELOADERR       W_ERROR(0x00000946)
+#define WERR_NERR_PROFILESAVEERR       W_ERROR(0x00000947)
+#define WERR_NERR_LOGOVERFLOW  W_ERROR(0x00000949)
+#define WERR_NERR_LOGFILECHANGED       W_ERROR(0x0000094A)
+#define WERR_NERR_LOGFILECORRUPT       W_ERROR(0x0000094B)
+#define WERR_NERR_SOURCEISDIR  W_ERROR(0x0000094C)
+#define WERR_NERR_BADSOURCE    W_ERROR(0x0000094D)
+#define WERR_NERR_BADDEST      W_ERROR(0x0000094E)
+#define WERR_NERR_DIFFERENTSERVERS     W_ERROR(0x0000094F)
+#define WERR_NERR_RUNSRVPAUSED W_ERROR(0x00000951)
+#define WERR_NERR_ERRCOMMRUNSRV        W_ERROR(0x00000955)
+#define WERR_NERR_ERROREXECINGGHOST    W_ERROR(0x00000957)
+#define WERR_NERR_SHARENOTFOUND        W_ERROR(0x00000958)
+#define WERR_NERR_INVALIDLANA  W_ERROR(0x00000960)
+#define WERR_NERR_OPENFILES    W_ERROR(0x00000961)
+#define WERR_NERR_ACTIVECONNS  W_ERROR(0x00000962)
+#define WERR_NERR_BADPASSWORDCORE      W_ERROR(0x00000963)
+#define WERR_NERR_DEVINUSE     W_ERROR(0x00000964)
+#define WERR_NERR_LOCALDRIVE   W_ERROR(0x00000965)
+#define WERR_NERR_ALERTEXISTS  W_ERROR(0x0000097E)
+#define WERR_NERR_TOOMANYALERTS        W_ERROR(0x0000097F)
+#define WERR_NERR_NOSUCHALERT  W_ERROR(0x00000980)
+#define WERR_NERR_BADRECIPIENT W_ERROR(0x00000981)
+#define WERR_NERR_ACCTLIMITEXCEEDED    W_ERROR(0x00000982)
+#define WERR_NERR_INVALIDLOGSEEK       W_ERROR(0x00000988)
+#define WERR_NERR_BADUASCONFIG W_ERROR(0x00000992)
+#define WERR_NERR_INVALIDUASOP W_ERROR(0x00000993)
+#define WERR_NERR_LASTADMIN    W_ERROR(0x00000994)
+#define WERR_NERR_DCNOTFOUND   W_ERROR(0x00000995)
+#define WERR_NERR_LOGONTRACKINGERROR   W_ERROR(0x00000996)
+#define WERR_NERR_NETLOGONNOTSTARTED   W_ERROR(0x00000997)
+#define WERR_NERR_CANNOTGROWUASFILE    W_ERROR(0x00000998)
+#define WERR_NERR_TIMEDIFFATDC W_ERROR(0x00000999)
+#define WERR_NERR_PASSWORDMISMATCH     W_ERROR(0x0000099A)
+#define WERR_NERR_NOSUCHSERVER W_ERROR(0x0000099C)
+#define WERR_NERR_NOSUCHSESSION        W_ERROR(0x0000099D)
+#define WERR_NERR_NOSUCHCONNECTION     W_ERROR(0x0000099E)
+#define WERR_NERR_TOOMANYSERVERS       W_ERROR(0x0000099F)
+#define WERR_NERR_TOOMANYSESSIONS      W_ERROR(0x000009A0)
+#define WERR_NERR_TOOMANYCONNECTIONS   W_ERROR(0x000009A1)
+#define WERR_NERR_TOOMANYFILES W_ERROR(0x000009A2)
+#define WERR_NERR_NOALTERNATESERVERS   W_ERROR(0x000009A3)
+#define WERR_NERR_TRYDOWNLEVEL W_ERROR(0x000009A6)
+#define WERR_NERR_UPSDRIVERNOTSTARTED  W_ERROR(0x000009B0)
+#define WERR_NERR_UPSINVALIDCONFIG     W_ERROR(0x000009B1)
+#define WERR_NERR_UPSINVALIDCOMMPORT   W_ERROR(0x000009B2)
+#define WERR_NERR_UPSSIGNALASSERTED    W_ERROR(0x000009B3)
+#define WERR_NERR_UPSSHUTDOWNFAILED    W_ERROR(0x000009B4)
+#define WERR_NERR_BADDOSRETCODE        W_ERROR(0x000009C4)
+#define WERR_NERR_PROGNEEDSEXTRAMEM    W_ERROR(0x000009C5)
+#define WERR_NERR_BADDOSFUNCTION       W_ERROR(0x000009C6)
+#define WERR_NERR_REMOTEBOOTFAILED     W_ERROR(0x000009C7)
+#define WERR_NERR_BADFILECHECKSUM      W_ERROR(0x000009C8)
+#define WERR_NERR_NORPLBOOTSYSTEM      W_ERROR(0x000009C9)
+#define WERR_NERR_RPLLOADRNETBIOSERR   W_ERROR(0x000009CA)
+#define WERR_NERR_RPLLOADRDISKERR      W_ERROR(0x000009CB)
+#define WERR_NERR_IMAGEPARAMERR        W_ERROR(0x000009CC)
+#define WERR_NERR_TOOMANYIMAGEPARAMS   W_ERROR(0x000009CD)
+#define WERR_NERR_NONDOSFLOPPYUSED     W_ERROR(0x000009CE)
+#define WERR_NERR_RPLBOOTRESTART       W_ERROR(0x000009CF)
+#define WERR_NERR_RPLSRVRCALLFAILED    W_ERROR(0x000009D0)
+#define WERR_NERR_CANTCONNECTRPLSRVR   W_ERROR(0x000009D1)
+#define WERR_NERR_CANTOPENIMAGEFILE    W_ERROR(0x000009D2)
+#define WERR_NERR_CALLINGRPLSRVR       W_ERROR(0x000009D3)
+#define WERR_NERR_STARTINGRPLBOOT      W_ERROR(0x000009D4)
+#define WERR_NERR_RPLBOOTSERVICETERM   W_ERROR(0x000009D5)
+#define WERR_NERR_RPLBOOTSTARTFAILED   W_ERROR(0x000009D6)
+#define WERR_NERR_RPL_CONNECTED        W_ERROR(0x000009D7)
+#define WERR_NERR_BROWSERCONFIGUREDTONOTRUN    W_ERROR(0x000009F6)
+#define WERR_NERR_RPLNOADAPTERSSTARTED W_ERROR(0x00000A32)
+#define WERR_NERR_RPLBADREGISTRY       W_ERROR(0x00000A33)
+#define WERR_NERR_RPLBADDATABASE       W_ERROR(0x00000A34)
+#define WERR_NERR_RPLRPLFILESSHARE     W_ERROR(0x00000A35)
+#define WERR_NERR_RPLNOTRPLSERVER      W_ERROR(0x00000A36)
+#define WERR_NERR_RPLCANNOTENUM        W_ERROR(0x00000A37)
+#define WERR_NERR_RPLWKSTAINFOCORRUPTED        W_ERROR(0x00000A38)
+#define WERR_NERR_RPLWKSTANOTFOUND     W_ERROR(0x00000A39)
+#define WERR_NERR_RPLWKSTANAMEUNAVAILABLE      W_ERROR(0x00000A3A)
+#define WERR_NERR_RPLPROFILEINFOCORRUPTED      W_ERROR(0x00000A3B)
+#define WERR_NERR_RPLPROFILENOTFOUND   W_ERROR(0x00000A3C)
+#define WERR_NERR_RPLPROFILENAMEUNAVAILABLE    W_ERROR(0x00000A3D)
+#define WERR_NERR_RPLPROFILENOTEMPTY   W_ERROR(0x00000A3E)
+#define WERR_NERR_RPLCONFIGINFOCORRUPTED       W_ERROR(0x00000A3F)
+#define WERR_NERR_RPLCONFIGNOTFOUND    W_ERROR(0x00000A40)
+#define WERR_NERR_RPLADAPTERINFOCORRUPTED      W_ERROR(0x00000A41)
+#define WERR_NERR_RPLINTERNAL  W_ERROR(0x00000A42)
+#define WERR_NERR_RPLVENDORINFOCORRUPTED       W_ERROR(0x00000A43)
+#define WERR_NERR_RPLBOOTINFOCORRUPTED W_ERROR(0x00000A44)
+#define WERR_NERR_RPLWKSTANEEDSUSERACCT        W_ERROR(0x00000A45)
+#define WERR_NERR_RPLNEEDSRPLUSERACCT  W_ERROR(0x00000A46)
+#define WERR_NERR_RPLBOOTNOTFOUND      W_ERROR(0x00000A47)
+#define WERR_NERR_RPLINCOMPATIBLEPROFILE       W_ERROR(0x00000A48)
+#define WERR_NERR_RPLADAPTERNAMEUNAVAILABLE    W_ERROR(0x00000A49)
+#define WERR_NERR_RPLCONFIGNOTEMPTY    W_ERROR(0x00000A4A)
+#define WERR_NERR_RPLBOOTINUSE W_ERROR(0x00000A4B)
+#define WERR_NERR_RPLBACKUPDATABASE    W_ERROR(0x00000A4C)
+#define WERR_NERR_RPLADAPTERNOTFOUND   W_ERROR(0x00000A4D)
+#define WERR_NERR_RPLVENDORNOTFOUND    W_ERROR(0x00000A4E)
+#define WERR_NERR_RPLVENDORNAMEUNAVAILABLE     W_ERROR(0x00000A4F)
+#define WERR_NERR_RPLBOOTNAMEUNAVAILABLE       W_ERROR(0x00000A50)
+#define WERR_NERR_RPLCONFIGNAMEUNAVAILABLE     W_ERROR(0x00000A51)
+#define WERR_NERR_DFSINTERNALCORRUPTION        W_ERROR(0x00000A64)
+#define WERR_NERR_DFSVOLUMEDATACORRUPT W_ERROR(0x00000A65)
+#define WERR_NERR_DFSNOSUCHVOLUME      W_ERROR(0x00000A66)
+#define WERR_NERR_DFSVOLUMEALREADYEXISTS       W_ERROR(0x00000A67)
+#define WERR_NERR_DFSALREADYSHARED     W_ERROR(0x00000A68)
+#define WERR_NERR_DFSNOSUCHSHARE       W_ERROR(0x00000A69)
+#define WERR_NERR_DFSNOTALEAFVOLUME    W_ERROR(0x00000A6A)
+#define WERR_NERR_DFSLEAFVOLUME        W_ERROR(0x00000A6B)
+#define WERR_NERR_DFSVOLUMEHASMULTIPLESERVERS  W_ERROR(0x00000A6C)
+#define WERR_NERR_DFSCANTCREATEJUNCTIONPOINT   W_ERROR(0x00000A6D)
+#define WERR_NERR_DFSSERVERNOTDFSAWARE W_ERROR(0x00000A6E)
+#define WERR_NERR_DFSBADRENAMEPATH     W_ERROR(0x00000A6F)
+#define WERR_NERR_DFSVOLUMEISOFFLINE   W_ERROR(0x00000A70)
+#define WERR_NERR_DFSNOSUCHSERVER      W_ERROR(0x00000A71)
+#define WERR_NERR_DFSCYCLICALNAME      W_ERROR(0x00000A72)
+#define WERR_NERR_DFSNOTSUPPORTEDINSERVERDFS   W_ERROR(0x00000A73)
+#define WERR_NERR_DFSDUPLICATESERVICE  W_ERROR(0x00000A74)
+#define WERR_NERR_DFSCANTREMOVELASTSERVERSHARE W_ERROR(0x00000A75)
+#define WERR_NERR_DFSVOLUMEISINTERDFS  W_ERROR(0x00000A76)
+#define WERR_NERR_DFSINCONSISTENT      W_ERROR(0x00000A77)
+#define WERR_NERR_DFSSERVERUPGRADED    W_ERROR(0x00000A78)
+#define WERR_NERR_DFSDATAISIDENTICAL   W_ERROR(0x00000A79)
+#define WERR_NERR_DFSCANTREMOVEDFSROOT W_ERROR(0x00000A7A)
+#define WERR_NERR_DFSCHILDORPARENTINDFS        W_ERROR(0x00000A7B)
+#define WERR_NERR_DFSINTERNALERROR     W_ERROR(0x00000A82)
+#define WERR_NERR_SETUPALREADYJOINED   W_ERROR(0x00000A83)
+#define WERR_NERR_SETUPNOTJOINED       W_ERROR(0x00000A84)
+#define WERR_NERR_SETUPDOMAINCONTROLLER        W_ERROR(0x00000A85)
+#define WERR_NERR_DEFAULTJOINREQUIRED  W_ERROR(0x00000A86)
+#define WERR_NERR_INVALIDWORKGROUPNAME W_ERROR(0x00000A87)
+#define WERR_NERR_NAMEUSESINCOMPATIBLECODEPAGE W_ERROR(0x00000A88)
+#define WERR_NERR_COMPUTERACCOUNTNOTFOUND      W_ERROR(0x00000A89)
+#define WERR_NERR_PERSONALSKU  W_ERROR(0x00000A8A)
+#define WERR_NERR_PASSWORDMUSTCHANGE   W_ERROR(0x00000A8D)
+#define WERR_NERR_ACCOUNTLOCKEDOUT     W_ERROR(0x00000A8E)
+#define WERR_NERR_PASSWORDTOOLONG      W_ERROR(0x00000A8F)
+#define WERR_NERR_PASSWORDNOTCOMPLEXENOUGH     W_ERROR(0x00000A90)
+#define WERR_NERR_PASSWORDFILTERERROR  W_ERROR(0x00000A91)
+#define WERR_SUCCESS_REBOOT_REQUIRED   W_ERROR(0x00000BC2)
+#define WERR_SUCCESS_RESTART_REQUIRED  W_ERROR(0x00000BC3)
+#define WERR_PRINTER_NOT_FOUND W_ERROR(0x00000BC4)
+#define WERR_PRINTER_DRIVER_WARNED     W_ERROR(0x00000BC5)
+#define WERR_PRINTER_DRIVER_BLOCKED    W_ERROR(0x00000BC6)
+#define WERR_PRINTER_DRIVER_PACKAGE_IN_USE     W_ERROR(0x00000BC7)
+#define WERR_CORE_DRIVER_PACKAGE_NOT_FOUND     W_ERROR(0x00000BC8)
+#define WERR_FAIL_REBOOT_REQUIRED      W_ERROR(0x00000BC9)
+#define WERR_FAIL_REBOOT_INITIATED     W_ERROR(0x00000BCA)
+#define WERR_IO_REISSUE_AS_CACHED      W_ERROR(0x00000F6E)
+#define WERR_WINS_INTERNAL     W_ERROR(0x00000FA0)
+#define WERR_CAN_NOT_DEL_LOCAL_WINS    W_ERROR(0x00000FA1)
+#define WERR_STATIC_INIT       W_ERROR(0x00000FA2)
+#define WERR_INC_BACKUP        W_ERROR(0x00000FA3)
+#define WERR_FULL_BACKUP       W_ERROR(0x00000FA4)
+#define WERR_REC_NON_EXISTENT  W_ERROR(0x00000FA5)
+#define WERR_RPL_NOT_ALLOWED   W_ERROR(0x00000FA6)
+#define WERR_DHCP_ADDRESS_CONFLICT     W_ERROR(0x00001004)
+#define WERR_WMI_GUID_NOT_FOUND        W_ERROR(0x00001068)
+#define WERR_WMI_INSTANCE_NOT_FOUND    W_ERROR(0x00001069)
+#define WERR_WMI_ITEMID_NOT_FOUND      W_ERROR(0x0000106A)
+#define WERR_WMI_TRY_AGAIN     W_ERROR(0x0000106B)
+#define WERR_WMI_DP_NOT_FOUND  W_ERROR(0x0000106C)
+#define WERR_WMI_UNRESOLVED_INSTANCE_REF       W_ERROR(0x0000106D)
+#define WERR_WMI_ALREADY_ENABLED       W_ERROR(0x0000106E)
+#define WERR_WMI_GUID_DISCONNECTED     W_ERROR(0x0000106F)
+#define WERR_WMI_SERVER_UNAVAILABLE    W_ERROR(0x00001070)
+#define WERR_WMI_DP_FAILED     W_ERROR(0x00001071)
+#define WERR_WMI_INVALID_MOF   W_ERROR(0x00001072)
+#define WERR_WMI_INVALID_REGINFO       W_ERROR(0x00001073)
+#define WERR_WMI_ALREADY_DISABLED      W_ERROR(0x00001074)
+#define WERR_WMI_READ_ONLY     W_ERROR(0x00001075)
+#define WERR_WMI_SET_FAILURE   W_ERROR(0x00001076)
+#define WERR_INVALID_MEDIA     W_ERROR(0x000010CC)
+#define WERR_INVALID_LIBRARY   W_ERROR(0x000010CD)
+#define WERR_INVALID_MEDIA_POOL        W_ERROR(0x000010CE)
+#define WERR_DRIVE_MEDIA_MISMATCH      W_ERROR(0x000010CF)
+#define WERR_MEDIA_OFFLINE     W_ERROR(0x000010D0)
+#define WERR_LIBRARY_OFFLINE   W_ERROR(0x000010D1)
+#define WERR_EMPTY     W_ERROR(0x000010D2)
+#define WERR_NOT_EMPTY W_ERROR(0x000010D3)
+#define WERR_MEDIA_UNAVAILABLE W_ERROR(0x000010D4)
+#define WERR_RESOURCE_DISABLED W_ERROR(0x000010D5)
+#define WERR_INVALID_CLEANER   W_ERROR(0x000010D6)
+#define WERR_UNABLE_TO_CLEAN   W_ERROR(0x000010D7)
+#define WERR_OBJECT_NOT_FOUND  W_ERROR(0x000010D8)
+#define WERR_DATABASE_FAILURE  W_ERROR(0x000010D9)
+#define WERR_DATABASE_FULL     W_ERROR(0x000010DA)
+#define WERR_MEDIA_INCOMPATIBLE        W_ERROR(0x000010DB)
+#define WERR_RESOURCE_NOT_PRESENT      W_ERROR(0x000010DC)
+#define WERR_INVALID_OPERATION W_ERROR(0x000010DD)
+#define WERR_MEDIA_NOT_AVAILABLE       W_ERROR(0x000010DE)
+#define WERR_REQUEST_REFUSED   W_ERROR(0x000010E0)
+#define WERR_INVALID_DRIVE_OBJECT      W_ERROR(0x000010E1)
+#define WERR_LIBRARY_FULL      W_ERROR(0x000010E2)
+#define WERR_MEDIUM_NOT_ACCESSIBLE     W_ERROR(0x000010E3)
+#define WERR_UNABLE_TO_LOAD_MEDIUM     W_ERROR(0x000010E4)
+#define WERR_UNABLE_TO_INVENTORY_DRIVE W_ERROR(0x000010E5)
+#define WERR_UNABLE_TO_INVENTORY_SLOT  W_ERROR(0x000010E6)
+#define WERR_UNABLE_TO_INVENTORY_TRANSPORT     W_ERROR(0x000010E7)
+#define WERR_TRANSPORT_FULL    W_ERROR(0x000010E8)
+#define WERR_CONTROLLING_IEPORT        W_ERROR(0x000010E9)
+#define WERR_UNABLE_TO_EJECT_MOUNTED_MEDIA     W_ERROR(0x000010EA)
+#define WERR_CLEANER_SLOT_SET  W_ERROR(0x000010EB)
+#define WERR_CLEANER_SLOT_NOT_SET      W_ERROR(0x000010EC)
+#define WERR_CLEANER_CARTRIDGE_SPENT   W_ERROR(0x000010ED)
+#define WERR_UNEXPECTED_OMID   W_ERROR(0x000010EE)
+#define WERR_CANT_DELETE_LAST_ITEM     W_ERROR(0x000010EF)
+#define WERR_MESSAGE_EXCEEDS_MAX_SIZE  W_ERROR(0x000010F0)
+#define WERR_VOLUME_CONTAINS_SYS_FILES W_ERROR(0x000010F1)
+#define WERR_INDIGENOUS_TYPE   W_ERROR(0x000010F2)
+#define WERR_NO_SUPPORTING_DRIVES      W_ERROR(0x000010F3)
+#define WERR_CLEANER_CARTRIDGE_INSTALLED       W_ERROR(0x000010F4)
+#define WERR_IEPORT_FULL       W_ERROR(0x000010F5)
+#define WERR_FILE_OFFLINE      W_ERROR(0x000010FE)
+#define WERR_REMOTE_STORAGE_NOT_ACTIVE W_ERROR(0x000010FF)
+#define WERR_REMOTE_STORAGE_MEDIA_ERROR        W_ERROR(0x00001100)
+#define WERR_NOT_A_REPARSE_POINT       W_ERROR(0x00001126)
+#define WERR_REPARSE_ATTRIBUTE_CONFLICT        W_ERROR(0x00001127)
+#define WERR_INVALID_REPARSE_DATA      W_ERROR(0x00001128)
+#define WERR_REPARSE_TAG_INVALID       W_ERROR(0x00001129)
+#define WERR_REPARSE_TAG_MISMATCH      W_ERROR(0x0000112A)
+#define WERR_VOLUME_NOT_SIS_ENABLED    W_ERROR(0x00001194)
+#define WERR_DEPENDENT_RESOURCE_EXISTS W_ERROR(0x00001389)
+#define WERR_DEPENDENCY_NOT_FOUND      W_ERROR(0x0000138A)
+#define WERR_DEPENDENCY_ALREADY_EXISTS W_ERROR(0x0000138B)
+#define WERR_RESOURCE_NOT_ONLINE       W_ERROR(0x0000138C)
+#define WERR_HOST_NODE_NOT_AVAILABLE   W_ERROR(0x0000138D)
+#define WERR_RESOURCE_NOT_AVAILABLE    W_ERROR(0x0000138E)
+#define WERR_RESOURCE_NOT_FOUND        W_ERROR(0x0000138F)
+#define WERR_SHUTDOWN_CLUSTER  W_ERROR(0x00001390)
+#define WERR_CANT_EVICT_ACTIVE_NODE    W_ERROR(0x00001391)
+#define WERR_OBJECT_ALREADY_EXISTS     W_ERROR(0x00001392)
+#define WERR_OBJECT_IN_LIST    W_ERROR(0x00001393)
+#define WERR_GROUP_NOT_AVAILABLE       W_ERROR(0x00001394)
+#define WERR_GROUP_NOT_FOUND   W_ERROR(0x00001395)
+#define WERR_GROUP_NOT_ONLINE  W_ERROR(0x00001396)
+#define WERR_HOST_NODE_NOT_RESOURCE_OWNER      W_ERROR(0x00001397)
+#define WERR_HOST_NODE_NOT_GROUP_OWNER W_ERROR(0x00001398)
+#define WERR_RESMON_CREATE_FAILED      W_ERROR(0x00001399)
+#define WERR_RESMON_ONLINE_FAILED      W_ERROR(0x0000139A)
+#define WERR_RESOURCE_ONLINE   W_ERROR(0x0000139B)
+#define WERR_QUORUM_RESOURCE   W_ERROR(0x0000139C)
+#define WERR_NOT_QUORUM_CAPABLE        W_ERROR(0x0000139D)
+#define WERR_CLUSTER_SHUTTING_DOWN     W_ERROR(0x0000139E)
+#define WERR_INVALID_STATE     W_ERROR(0x0000139F)
+#define WERR_RESOURCE_PROPERTIES_STORED        W_ERROR(0x000013A0)
+#define WERR_NOT_QUORUM_CLASS  W_ERROR(0x000013A1)
+#define WERR_CORE_RESOURCE     W_ERROR(0x000013A2)
+#define WERR_QUORUM_RESOURCE_ONLINE_FAILED     W_ERROR(0x000013A3)
+#define WERR_QUORUMLOG_OPEN_FAILED     W_ERROR(0x000013A4)
+#define WERR_CLUSTERLOG_CORRUPT        W_ERROR(0x000013A5)
+#define WERR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE W_ERROR(0x000013A6)
+#define WERR_CLUSTERLOG_EXCEEDS_MAXSIZE        W_ERROR(0x000013A7)
+#define WERR_CLUSTERLOG_CHKPOINT_NOT_FOUND     W_ERROR(0x000013A8)
+#define WERR_CLUSTERLOG_NOT_ENOUGH_SPACE       W_ERROR(0x000013A9)
+#define WERR_QUORUM_OWNER_ALIVE        W_ERROR(0x000013AA)
+#define WERR_NETWORK_NOT_AVAILABLE     W_ERROR(0x000013AB)
+#define WERR_NODE_NOT_AVAILABLE        W_ERROR(0x000013AC)
+#define WERR_ALL_NODES_NOT_AVAILABLE   W_ERROR(0x000013AD)
+#define WERR_RESOURCE_FAILED   W_ERROR(0x000013AE)
+#define WERR_CLUSTER_INVALID_NODE      W_ERROR(0x000013AF)
+#define WERR_CLUSTER_NODE_EXISTS       W_ERROR(0x000013B0)
+#define WERR_CLUSTER_JOIN_IN_PROGRESS  W_ERROR(0x000013B1)
+#define WERR_CLUSTER_NODE_NOT_FOUND    W_ERROR(0x000013B2)
+#define WERR_CLUSTER_LOCAL_NODE_NOT_FOUND      W_ERROR(0x000013B3)
+#define WERR_CLUSTER_NETWORK_EXISTS    W_ERROR(0x000013B4)
+#define WERR_CLUSTER_NETWORK_NOT_FOUND W_ERROR(0x000013B5)
+#define WERR_CLUSTER_NETINTERFACE_EXISTS       W_ERROR(0x000013B6)
+#define WERR_CLUSTER_NETINTERFACE_NOT_FOUND    W_ERROR(0x000013B7)
+#define WERR_CLUSTER_INVALID_REQUEST   W_ERROR(0x000013B8)
+#define WERR_CLUSTER_INVALID_NETWORK_PROVIDER  W_ERROR(0x000013B9)
+#define WERR_CLUSTER_NODE_DOWN W_ERROR(0x000013BA)
+#define WERR_CLUSTER_NODE_UNREACHABLE  W_ERROR(0x000013BB)
+#define WERR_CLUSTER_NODE_NOT_MEMBER   W_ERROR(0x000013BC)
+#define WERR_CLUSTER_JOIN_NOT_IN_PROGRESS      W_ERROR(0x000013BD)
+#define WERR_CLUSTER_INVALID_NETWORK   W_ERROR(0x000013BE)
+#define WERR_CLUSTER_NODE_UP   W_ERROR(0x000013C0)
+#define WERR_CLUSTER_IPADDR_IN_USE     W_ERROR(0x000013C1)
+#define WERR_CLUSTER_NODE_NOT_PAUSED   W_ERROR(0x000013C2)
+#define WERR_CLUSTER_NO_SECURITY_CONTEXT       W_ERROR(0x000013C3)
+#define WERR_CLUSTER_NETWORK_NOT_INTERNAL      W_ERROR(0x000013C4)
+#define WERR_CLUSTER_NODE_ALREADY_UP   W_ERROR(0x000013C5)
+#define WERR_CLUSTER_NODE_ALREADY_DOWN W_ERROR(0x000013C6)
+#define WERR_CLUSTER_NETWORK_ALREADY_ONLINE    W_ERROR(0x000013C7)
+#define WERR_CLUSTER_NETWORK_ALREADY_OFFLINE   W_ERROR(0x000013C8)
+#define WERR_CLUSTER_NODE_ALREADY_MEMBER       W_ERROR(0x000013C9)
+#define WERR_CLUSTER_LAST_INTERNAL_NETWORK     W_ERROR(0x000013CA)
+#define WERR_CLUSTER_NETWORK_HAS_DEPENDENTS    W_ERROR(0x000013CB)
+#define WERR_INVALID_OPERATION_ON_QUORUM       W_ERROR(0x000013CC)
+#define WERR_DEPENDENCY_NOT_ALLOWED    W_ERROR(0x000013CD)
+#define WERR_CLUSTER_NODE_PAUSED       W_ERROR(0x000013CE)
+#define WERR_NODE_CANT_HOST_RESOURCE   W_ERROR(0x000013CF)
+#define WERR_CLUSTER_NODE_NOT_READY    W_ERROR(0x000013D0)
+#define WERR_CLUSTER_NODE_SHUTTING_DOWN        W_ERROR(0x000013D1)
+#define WERR_CLUSTER_JOIN_ABORTED      W_ERROR(0x000013D2)
+#define WERR_CLUSTER_INCOMPATIBLE_VERSIONS     W_ERROR(0x000013D3)
+#define WERR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED      W_ERROR(0x000013D4)
+#define WERR_CLUSTER_SYSTEM_CONFIG_CHANGED     W_ERROR(0x000013D5)
+#define WERR_CLUSTER_RESOURCE_TYPE_NOT_FOUND   W_ERROR(0x000013D6)
+#define WERR_CLUSTER_RESTYPE_NOT_SUPPORTED     W_ERROR(0x000013D7)
+#define WERR_CLUSTER_RESNAME_NOT_FOUND W_ERROR(0x000013D8)
+#define WERR_CLUSTER_NO_RPC_PACKAGES_REGISTERED        W_ERROR(0x000013D9)
+#define WERR_CLUSTER_OWNER_NOT_IN_PREFLIST     W_ERROR(0x000013DA)
+#define WERR_CLUSTER_DATABASE_SEQMISMATCH      W_ERROR(0x000013DB)
+#define WERR_RESMON_INVALID_STATE      W_ERROR(0x000013DC)
+#define WERR_CLUSTER_GUM_NOT_LOCKER    W_ERROR(0x000013DD)
+#define WERR_QUORUM_DISK_NOT_FOUND     W_ERROR(0x000013DE)
+#define WERR_DATABASE_BACKUP_CORRUPT   W_ERROR(0x000013DF)
+#define WERR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT W_ERROR(0x000013E0)
+#define WERR_RESOURCE_PROPERTY_UNCHANGEABLE    W_ERROR(0x000013E1)
+#define WERR_CLUSTER_MEMBERSHIP_INVALID_STATE  W_ERROR(0x00001702)
+#define WERR_CLUSTER_QUORUMLOG_NOT_FOUND       W_ERROR(0x00001703)
+#define WERR_CLUSTER_MEMBERSHIP_HALT   W_ERROR(0x00001704)
+#define WERR_CLUSTER_INSTANCE_ID_MISMATCH      W_ERROR(0x00001705)
+#define WERR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP  W_ERROR(0x00001706)
+#define WERR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH       W_ERROR(0x00001707)
+#define WERR_CLUSTER_EVICT_WITHOUT_CLEANUP     W_ERROR(0x00001708)
+#define WERR_CLUSTER_PARAMETER_MISMATCH        W_ERROR(0x00001709)
+#define WERR_NODE_CANNOT_BE_CLUSTERED  W_ERROR(0x0000170A)
+#define WERR_CLUSTER_WRONG_OS_VERSION  W_ERROR(0x0000170B)
+#define WERR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME      W_ERROR(0x0000170C)
+#define WERR_CLUSCFG_ALREADY_COMMITTED W_ERROR(0x0000170D)
+#define WERR_CLUSCFG_ROLLBACK_FAILED   W_ERROR(0x0000170E)
+#define WERR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT W_ERROR(0x0000170F)
+#define WERR_CLUSTER_OLD_VERSION       W_ERROR(0x00001710)
+#define WERR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME     W_ERROR(0x00001711)
+#define WERR_CLUSTER_NO_NET_ADAPTERS   W_ERROR(0x00001712)
+#define WERR_CLUSTER_POISONED  W_ERROR(0x00001713)
+#define WERR_CLUSTER_GROUP_MOVING      W_ERROR(0x00001714)
+#define WERR_CLUSTER_RESOURCE_TYPE_BUSY        W_ERROR(0x00001715)
+#define WERR_RESOURCE_CALL_TIMED_OUT   W_ERROR(0x00001716)
+#define WERR_INVALID_CLUSTER_IPV6_ADDRESS      W_ERROR(0x00001717)
+#define WERR_CLUSTER_INTERNAL_INVALID_FUNCTION W_ERROR(0x00001718)
+#define WERR_CLUSTER_PARAMETER_OUT_OF_BOUNDS   W_ERROR(0x00001719)
+#define WERR_CLUSTER_PARTIAL_SEND      W_ERROR(0x0000171A)
+#define WERR_CLUSTER_REGISTRY_INVALID_FUNCTION W_ERROR(0x0000171B)
+#define WERR_CLUSTER_INVALID_STRING_TERMINATION        W_ERROR(0x0000171C)
+#define WERR_CLUSTER_INVALID_STRING_FORMAT     W_ERROR(0x0000171D)
+#define WERR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS  W_ERROR(0x0000171E)
+#define WERR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS      W_ERROR(0x0000171F)
+#define WERR_CLUSTER_NULL_DATA W_ERROR(0x00001720)
+#define WERR_CLUSTER_PARTIAL_READ      W_ERROR(0x00001721)
+#define WERR_CLUSTER_PARTIAL_WRITE     W_ERROR(0x00001722)
+#define WERR_CLUSTER_CANT_DESERIALIZE_DATA     W_ERROR(0x00001723)
+#define WERR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT      W_ERROR(0x00001724)
+#define WERR_CLUSTER_NO_QUORUM W_ERROR(0x00001725)
+#define WERR_CLUSTER_INVALID_IPV6_NETWORK      W_ERROR(0x00001726)
+#define WERR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK       W_ERROR(0x00001727)
+#define WERR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP  W_ERROR(0x00001728)
+#define WERR_ENCRYPTION_FAILED W_ERROR(0x00001770)
+#define WERR_DECRYPTION_FAILED W_ERROR(0x00001771)
+#define WERR_FILE_ENCRYPTED    W_ERROR(0x00001772)
+#define WERR_NO_RECOVERY_POLICY        W_ERROR(0x00001773)
+#define WERR_NO_EFS    W_ERROR(0x00001774)
+#define WERR_WRONG_EFS W_ERROR(0x00001775)
+#define WERR_NO_USER_KEYS      W_ERROR(0x00001776)
+#define WERR_FILE_NOT_ENCRYPTED        W_ERROR(0x00001777)
+#define WERR_NOT_EXPORT_FORMAT W_ERROR(0x00001778)
+#define WERR_FILE_READ_ONLY    W_ERROR(0x00001779)
+#define WERR_DIR_EFS_DISALLOWED        W_ERROR(0x0000177A)
+#define WERR_EFS_SERVER_NOT_TRUSTED    W_ERROR(0x0000177B)
+#define WERR_BAD_RECOVERY_POLICY       W_ERROR(0x0000177C)
+#define WERR_EFS_ALG_BLOB_TOO_BIG      W_ERROR(0x0000177D)
+#define WERR_VOLUME_NOT_SUPPORT_EFS    W_ERROR(0x0000177E)
+#define WERR_EFS_DISABLED      W_ERROR(0x0000177F)
+#define WERR_EFS_VERSION_NOT_SUPPORT   W_ERROR(0x00001780)
+#define WERR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE     W_ERROR(0x00001781)
+#define WERR_CS_ENCRYPTION_UNSUPPORTED_SERVER  W_ERROR(0x00001782)
+#define WERR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE     W_ERROR(0x00001783)
+#define WERR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE  W_ERROR(0x00001784)
+#define WERR_CS_ENCRYPTION_FILE_NOT_CSE        W_ERROR(0x00001785)
+#define WERR_NO_BROWSER_SERVERS_FOUND  W_ERROR(0x000017E6)
+#define WERR_LOG_SECTOR_INVALID        W_ERROR(0x000019C8)
+#define WERR_LOG_SECTOR_PARITY_INVALID W_ERROR(0x000019C9)
+#define WERR_LOG_SECTOR_REMAPPED       W_ERROR(0x000019CA)
+#define WERR_LOG_BLOCK_INCOMPLETE      W_ERROR(0x000019CB)
+#define WERR_LOG_INVALID_RANGE W_ERROR(0x000019CC)
+#define WERR_LOG_BLOCKS_EXHAUSTED      W_ERROR(0x000019CD)
+#define WERR_LOG_READ_CONTEXT_INVALID  W_ERROR(0x000019CE)
+#define WERR_LOG_RESTART_INVALID       W_ERROR(0x000019CF)
+#define WERR_LOG_BLOCK_VERSION W_ERROR(0x000019D0)
+#define WERR_LOG_BLOCK_INVALID W_ERROR(0x000019D1)
+#define WERR_LOG_READ_MODE_INVALID     W_ERROR(0x000019D2)
+#define WERR_LOG_NO_RESTART    W_ERROR(0x000019D3)
+#define WERR_LOG_METADATA_CORRUPT      W_ERROR(0x000019D4)
+#define WERR_LOG_METADATA_INVALID      W_ERROR(0x000019D5)
+#define WERR_LOG_METADATA_INCONSISTENT W_ERROR(0x000019D6)
+#define WERR_LOG_RESERVATION_INVALID   W_ERROR(0x000019D7)
+#define WERR_LOG_CANT_DELETE   W_ERROR(0x000019D8)
+#define WERR_LOG_CONTAINER_LIMIT_EXCEEDED      W_ERROR(0x000019D9)
+#define WERR_LOG_START_OF_LOG  W_ERROR(0x000019DA)
+#define WERR_LOG_POLICY_ALREADY_INSTALLED      W_ERROR(0x000019DB)
+#define WERR_LOG_POLICY_NOT_INSTALLED  W_ERROR(0x000019DC)
+#define WERR_LOG_POLICY_INVALID        W_ERROR(0x000019DD)
+#define WERR_LOG_POLICY_CONFLICT       W_ERROR(0x000019DE)
+#define WERR_LOG_PINNED_ARCHIVE_TAIL   W_ERROR(0x000019DF)
+#define WERR_LOG_RECORD_NONEXISTENT    W_ERROR(0x000019E0)
+#define WERR_LOG_RECORDS_RESERVED_INVALID      W_ERROR(0x000019E1)
+#define WERR_LOG_SPACE_RESERVED_INVALID        W_ERROR(0x000019E2)
+#define WERR_LOG_TAIL_INVALID  W_ERROR(0x000019E3)
+#define WERR_LOG_FULL  W_ERROR(0x000019E4)
+#define WERR_COULD_NOT_RESIZE_LOG      W_ERROR(0x000019E5)
+#define WERR_LOG_MULTIPLEXED   W_ERROR(0x000019E6)
+#define WERR_LOG_DEDICATED     W_ERROR(0x000019E7)
+#define WERR_LOG_ARCHIVE_NOT_IN_PROGRESS       W_ERROR(0x000019E8)
+#define WERR_LOG_ARCHIVE_IN_PROGRESS   W_ERROR(0x000019E9)
+#define WERR_LOG_EPHEMERAL     W_ERROR(0x000019EA)
+#define WERR_LOG_NOT_ENOUGH_CONTAINERS W_ERROR(0x000019EB)
+#define WERR_LOG_CLIENT_ALREADY_REGISTERED     W_ERROR(0x000019EC)
+#define WERR_LOG_CLIENT_NOT_REGISTERED W_ERROR(0x000019ED)
+#define WERR_LOG_FULL_HANDLER_IN_PROGRESS      W_ERROR(0x000019EE)
+#define WERR_LOG_CONTAINER_READ_FAILED W_ERROR(0x000019EF)
+#define WERR_LOG_CONTAINER_WRITE_FAILED        W_ERROR(0x000019F0)
+#define WERR_LOG_CONTAINER_OPEN_FAILED W_ERROR(0x000019F1)
+#define WERR_LOG_CONTAINER_STATE_INVALID       W_ERROR(0x000019F2)
+#define WERR_LOG_STATE_INVALID W_ERROR(0x000019F3)
+#define WERR_LOG_PINNED        W_ERROR(0x000019F4)
+#define WERR_LOG_METADATA_FLUSH_FAILED W_ERROR(0x000019F5)
+#define WERR_LOG_INCONSISTENT_SECURITY W_ERROR(0x000019F6)
+#define WERR_LOG_APPENDED_FLUSH_FAILED W_ERROR(0x000019F7)
+#define WERR_LOG_PINNED_RESERVATION    W_ERROR(0x000019F8)
+#define WERR_INVALID_TRANSACTION       W_ERROR(0x00001A2C)
+#define WERR_TRANSACTION_NOT_ACTIVE    W_ERROR(0x00001A2D)
+#define WERR_TRANSACTION_REQUEST_NOT_VALID     W_ERROR(0x00001A2E)
+#define WERR_TRANSACTION_NOT_REQUESTED W_ERROR(0x00001A2F)
+#define WERR_TRANSACTION_ALREADY_ABORTED       W_ERROR(0x00001A30)
+#define WERR_TRANSACTION_ALREADY_COMMITTED     W_ERROR(0x00001A31)
+#define WERR_TM_INITIALIZATION_FAILED  W_ERROR(0x00001A32)
+#define WERR_RESOURCEMANAGER_READ_ONLY W_ERROR(0x00001A33)
+#define WERR_TRANSACTION_NOT_JOINED    W_ERROR(0x00001A34)
+#define WERR_TRANSACTION_SUPERIOR_EXISTS       W_ERROR(0x00001A35)
+#define WERR_CRM_PROTOCOL_ALREADY_EXISTS       W_ERROR(0x00001A36)
+#define WERR_TRANSACTION_PROPAGATION_FAILED    W_ERROR(0x00001A37)
+#define WERR_CRM_PROTOCOL_NOT_FOUND    W_ERROR(0x00001A38)
+#define WERR_TRANSACTION_INVALID_MARSHALL_BUFFER       W_ERROR(0x00001A39)
+#define WERR_CURRENT_TRANSACTION_NOT_VALID     W_ERROR(0x00001A3A)
+#define WERR_TRANSACTION_NOT_FOUND     W_ERROR(0x00001A3B)
+#define WERR_RESOURCEMANAGER_NOT_FOUND W_ERROR(0x00001A3C)
+#define WERR_ENLISTMENT_NOT_FOUND      W_ERROR(0x00001A3D)
+#define WERR_TRANSACTIONMANAGER_NOT_FOUND      W_ERROR(0x00001A3E)
+#define WERR_TRANSACTIONMANAGER_NOT_ONLINE     W_ERROR(0x00001A3F)
+#define WERR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION        W_ERROR(0x00001A40)
+#define WERR_TRANSACTIONAL_CONFLICT    W_ERROR(0x00001A90)
+#define WERR_RM_NOT_ACTIVE     W_ERROR(0x00001A91)
+#define WERR_RM_METADATA_CORRUPT       W_ERROR(0x00001A92)
+#define WERR_DIRECTORY_NOT_RM  W_ERROR(0x00001A93)
+#define WERR_TRANSACTIONS_UNSUPPORTED_REMOTE   W_ERROR(0x00001A95)
+#define WERR_LOG_RESIZE_INVALID_SIZE   W_ERROR(0x00001A96)
+#define WERR_OBJECT_NO_LONGER_EXISTS   W_ERROR(0x00001A97)
+#define WERR_STREAM_MINIVERSION_NOT_FOUND      W_ERROR(0x00001A98)
+#define WERR_STREAM_MINIVERSION_NOT_VALID      W_ERROR(0x00001A99)
+#define WERR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION       W_ERROR(0x00001A9A)
+#define WERR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT  W_ERROR(0x00001A9B)
+#define WERR_CANT_CREATE_MORE_STREAM_MINIVERSIONS      W_ERROR(0x00001A9C)
+#define WERR_REMOTE_FILE_VERSION_MISMATCH      W_ERROR(0x00001A9E)
+#define WERR_HANDLE_NO_LONGER_VALID    W_ERROR(0x00001A9F)
+#define WERR_NO_TXF_METADATA   W_ERROR(0x00001AA0)
+#define WERR_LOG_CORRUPTION_DETECTED   W_ERROR(0x00001AA1)
+#define WERR_CANT_RECOVER_WITH_HANDLE_OPEN     W_ERROR(0x00001AA2)
+#define WERR_RM_DISCONNECTED   W_ERROR(0x00001AA3)
+#define WERR_ENLISTMENT_NOT_SUPERIOR   W_ERROR(0x00001AA4)
+#define WERR_RECOVERY_NOT_NEEDED       W_ERROR(0x00001AA5)
+#define WERR_RM_ALREADY_STARTED        W_ERROR(0x00001AA6)
+#define WERR_FILE_IDENTITY_NOT_PERSISTENT      W_ERROR(0x00001AA7)
+#define WERR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY       W_ERROR(0x00001AA8)
+#define WERR_CANT_CROSS_RM_BOUNDARY    W_ERROR(0x00001AA9)
+#define WERR_TXF_DIR_NOT_EMPTY W_ERROR(0x00001AAA)
+#define WERR_INDOUBT_TRANSACTIONS_EXIST        W_ERROR(0x00001AAB)
+#define WERR_TM_VOLATILE       W_ERROR(0x00001AAC)
+#define WERR_ROLLBACK_TIMER_EXPIRED    W_ERROR(0x00001AAD)
+#define WERR_TXF_ATTRIBUTE_CORRUPT     W_ERROR(0x00001AAE)
+#define WERR_EFS_NOT_ALLOWED_IN_TRANSACTION    W_ERROR(0x00001AAF)
+#define WERR_TRANSACTIONAL_OPEN_NOT_ALLOWED    W_ERROR(0x00001AB0)
+#define WERR_LOG_GROWTH_FAILED W_ERROR(0x00001AB1)
+#define WERR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE     W_ERROR(0x00001AB2)
+#define WERR_TXF_METADATA_ALREADY_PRESENT      W_ERROR(0x00001AB3)
+#define WERR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET       W_ERROR(0x00001AB4)
+#define WERR_TRANSACTION_REQUIRED_PROMOTION    W_ERROR(0x00001AB5)
+#define WERR_CANNOT_EXECUTE_FILE_IN_TRANSACTION        W_ERROR(0x00001AB6)
+#define WERR_TRANSACTIONS_NOT_FROZEN   W_ERROR(0x00001AB7)
+#define WERR_TRANSACTION_FREEZE_IN_PROGRESS    W_ERROR(0x00001AB8)
+#define WERR_NOT_SNAPSHOT_VOLUME       W_ERROR(0x00001AB9)
+#define WERR_NO_SAVEPOINT_WITH_OPEN_FILES      W_ERROR(0x00001ABA)
+#define WERR_DATA_LOST_REPAIR  W_ERROR(0x00001ABB)
+#define WERR_SPARSE_NOT_ALLOWED_IN_TRANSACTION W_ERROR(0x00001ABC)
+#define WERR_TM_IDENTITY_MISMATCH      W_ERROR(0x00001ABD)
+#define WERR_FLOATED_SECTION   W_ERROR(0x00001ABE)
+#define WERR_CANNOT_ACCEPT_TRANSACTED_WORK     W_ERROR(0x00001ABF)
+#define WERR_CANNOT_ABORT_TRANSACTIONS W_ERROR(0x00001AC0)
+#define WERR_CTX_WINSTATION_NAME_INVALID       W_ERROR(0x00001B59)
+#define WERR_CTX_INVALID_PD    W_ERROR(0x00001B5A)
+#define WERR_CTX_PD_NOT_FOUND  W_ERROR(0x00001B5B)
+#define WERR_CTX_WD_NOT_FOUND  W_ERROR(0x00001B5C)
+#define WERR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY    W_ERROR(0x00001B5D)
+#define WERR_CTX_SERVICE_NAME_COLLISION        W_ERROR(0x00001B5E)
+#define WERR_CTX_CLOSE_PENDING W_ERROR(0x00001B5F)
+#define WERR_CTX_NO_OUTBUF     W_ERROR(0x00001B60)
+#define WERR_CTX_MODEM_INF_NOT_FOUND   W_ERROR(0x00001B61)
+#define WERR_CTX_INVALID_MODEMNAME     W_ERROR(0x00001B62)
+#define WERR_CTX_MODEM_RESPONSE_ERROR  W_ERROR(0x00001B63)
+#define WERR_CTX_MODEM_RESPONSE_TIMEOUT        W_ERROR(0x00001B64)
+#define WERR_CTX_MODEM_RESPONSE_NO_CARRIER     W_ERROR(0x00001B65)
+#define WERR_CTX_MODEM_RESPONSE_NO_DIALTONE    W_ERROR(0x00001B66)
+#define WERR_CTX_MODEM_RESPONSE_BUSY   W_ERROR(0x00001B67)
+#define WERR_CTX_MODEM_RESPONSE_VOICE  W_ERROR(0x00001B68)
+#define WERR_CTX_TD_ERROR      W_ERROR(0x00001B69)
+#define WERR_CTX_WINSTATION_NOT_FOUND  W_ERROR(0x00001B6E)
+#define WERR_CTX_WINSTATION_ALREADY_EXISTS     W_ERROR(0x00001B6F)
+#define WERR_CTX_WINSTATION_BUSY       W_ERROR(0x00001B70)
+#define WERR_CTX_BAD_VIDEO_MODE        W_ERROR(0x00001B71)
+#define WERR_CTX_GRAPHICS_INVALID      W_ERROR(0x00001B7B)
+#define WERR_CTX_LOGON_DISABLED        W_ERROR(0x00001B7D)
+#define WERR_CTX_NOT_CONSOLE   W_ERROR(0x00001B7E)
+#define WERR_CTX_CLIENT_QUERY_TIMEOUT  W_ERROR(0x00001B80)
+#define WERR_CTX_CONSOLE_DISCONNECT    W_ERROR(0x00001B81)
+#define WERR_CTX_CONSOLE_CONNECT       W_ERROR(0x00001B82)
+#define WERR_CTX_SHADOW_DENIED W_ERROR(0x00001B84)
+#define WERR_CTX_WINSTATION_ACCESS_DENIED      W_ERROR(0x00001B85)
+#define WERR_CTX_INVALID_WD    W_ERROR(0x00001B89)
+#define WERR_CTX_SHADOW_INVALID        W_ERROR(0x00001B8A)
+#define WERR_CTX_SHADOW_DISABLED       W_ERROR(0x00001B8B)
+#define WERR_CTX_CLIENT_LICENSE_IN_USE W_ERROR(0x00001B8C)
+#define WERR_CTX_CLIENT_LICENSE_NOT_SET        W_ERROR(0x00001B8D)
+#define WERR_CTX_LICENSE_NOT_AVAILABLE W_ERROR(0x00001B8E)
+#define WERR_CTX_LICENSE_CLIENT_INVALID        W_ERROR(0x00001B8F)
+#define WERR_CTX_LICENSE_EXPIRED       W_ERROR(0x00001B90)
+#define WERR_CTX_SHADOW_NOT_RUNNING    W_ERROR(0x00001B91)
+#define WERR_CTX_SHADOW_ENDED_BY_MODE_CHANGE   W_ERROR(0x00001B92)
+#define WERR_ACTIVATION_COUNT_EXCEEDED W_ERROR(0x00001B93)
+#define WERR_CTX_WINSTATIONS_DISABLED  W_ERROR(0x00001B94)
+#define WERR_CTX_ENCRYPTION_LEVEL_REQUIRED     W_ERROR(0x00001B95)
+#define WERR_CTX_SESSION_IN_USE        W_ERROR(0x00001B96)
+#define WERR_CTX_NO_FORCE_LOGOFF       W_ERROR(0x00001B97)
+#define WERR_CTX_ACCOUNT_RESTRICTION   W_ERROR(0x00001B98)
+#define WERR_RDP_PROTOCOL_ERROR        W_ERROR(0x00001B99)
+#define WERR_CTX_CDM_CONNECT   W_ERROR(0x00001B9A)
+#define WERR_CTX_CDM_DISCONNECT        W_ERROR(0x00001B9B)
+#define WERR_CTX_SECURITY_LAYER_ERROR  W_ERROR(0x00001B9C)
+#define WERR_TS_INCOMPATIBLE_SESSIONS  W_ERROR(0x00001B9D)
+#define WERR_FRS_ERR_INVALID_API_SEQUENCE      W_ERROR(0x00001F41)
+#define WERR_FRS_ERR_STARTING_SERVICE  W_ERROR(0x00001F42)
+#define WERR_FRS_ERR_STOPPING_SERVICE  W_ERROR(0x00001F43)
+#define WERR_FRS_ERR_INTERNAL_API      W_ERROR(0x00001F44)
+#define WERR_FRS_ERR_INTERNAL  W_ERROR(0x00001F45)
+#define WERR_FRS_ERR_SERVICE_COMM      W_ERROR(0x00001F46)
+#define WERR_FRS_ERR_INSUFFICIENT_PRIV W_ERROR(0x00001F47)
+#define WERR_FRS_ERR_AUTHENTICATION    W_ERROR(0x00001F48)
+#define WERR_FRS_ERR_PARENT_INSUFFICIENT_PRIV  W_ERROR(0x00001F49)
+#define WERR_FRS_ERR_PARENT_AUTHENTICATION     W_ERROR(0x00001F4A)
+#define WERR_FRS_ERR_CHILD_TO_PARENT_COMM      W_ERROR(0x00001F4B)
+#define WERR_FRS_ERR_PARENT_TO_CHILD_COMM      W_ERROR(0x00001F4C)
+#define WERR_FRS_ERR_SYSVOL_POPULATE   W_ERROR(0x00001F4D)
+#define WERR_FRS_ERR_SYSVOL_POPULATE_TIMEOUT   W_ERROR(0x00001F4E)
+#define WERR_FRS_ERR_SYSVOL_IS_BUSY    W_ERROR(0x00001F4F)
+#define WERR_FRS_ERR_SYSVOL_DEMOTE     W_ERROR(0x00001F50)
+#define WERR_FRS_ERR_INVALID_SERVICE_PARAMETER W_ERROR(0x00001F51)
+#define WERR_DS_NOT_INSTALLED  W_ERROR(0x00002008)
+#define WERR_DS_MEMBERSHIP_EVALUATED_LOCALLY   W_ERROR(0x00002009)
+#define WERR_DS_INVALID_ATTRIBUTE_YNTAX        W_ERROR(0x0000200B)
+#define WERR_DS_NO_RIDS_ALLOCATED      W_ERROR(0x00002010)
+#define WERR_DS_NO_MORE_RIDS   W_ERROR(0x00002011)
+#define WERR_DS_INCORRECT_ROLE_OWNER   W_ERROR(0x00002012)
+#define WERR_DS_RIDMGR_INIT_ERROR      W_ERROR(0x00002013)
+#define WERR_DS_CROSS_DOM_MOVE_ERROR   W_ERROR(0x00002018)
+#define WERR_DS_GC_NOT_AVAILABLE       W_ERROR(0x00002019)
+#define WERR_SHARED_POLICY     W_ERROR(0x0000201A)
+#define WERR_POLICY_OBJECT_NOT_FOUND   W_ERROR(0x0000201B)
+#define WERR_POLICY_ONLY_IN_DS W_ERROR(0x0000201C)
+#define WERR_PROMOTION_ACTIVE  W_ERROR(0x0000201D)
+#define WERR_NO_PROMOTION_ACTIVE       W_ERROR(0x0000201E)
+#define WERR_DS_SIZELIMIT_EXCEEDED     W_ERROR(0x00002023)
+#define WERR_DS_AUTH_UNKNOWN   W_ERROR(0x0000202A)
+#define WERR_DS_IS_LEAF        W_ERROR(0x00002033)
+#define WERR_DS_OBJECT_RESULTS_TOO_LARGE       W_ERROR(0x00002038)
+#define WERR_DS_SERVER_DOWN    W_ERROR(0x0000203A)
+#define WERR_DS_LOCAL_ERROR    W_ERROR(0x0000203B)
+#define WERR_DS_ENCODING_ERROR W_ERROR(0x0000203C)
+#define WERR_DS_DECODING_ERROR W_ERROR(0x0000203D)
+#define WERR_DS_FILTER_UNKNOWN W_ERROR(0x0000203E)
+#define WERR_DS_PARAM_ERROR    W_ERROR(0x0000203F)
+#define WERR_DS_NOT_SUPPORTED  W_ERROR(0x00002040)
+#define WERR_DS_NO_RESULTS_RETURNED    W_ERROR(0x00002041)
+#define WERR_DS_CONTROL_NOT_FOUND      W_ERROR(0x00002042)
+#define WERR_DS_CLIENT_LOOP    W_ERROR(0x00002043)
+#define WERR_DS_REFERRAL_LIMIT_EXCEEDED        W_ERROR(0x00002044)
+#define WERR_DS_SORT_CONTROL_MISSING   W_ERROR(0x00002045)
+#define WERR_DS_OFFSET_RANGE_ERROR     W_ERROR(0x00002046)
+#define WERR_DS_ROOT_MUST_BE_NC        W_ERROR(0x0000206D)
+#define WERR_DS_ADD_REPLICA_INHIBITED  W_ERROR(0x0000206E)
+#define WERR_DS_ATT_NOT_DEF_IN_SCHEMA  W_ERROR(0x0000206F)
+#define WERR_DS_MAX_OBJ_SIZE_EXCEEDED  W_ERROR(0x00002070)
+#define WERR_DS_NO_RDN_DEFINED_IN_SCHEMA       W_ERROR(0x00002072)
+#define WERR_DS_RDN_DOESNT_MATCH_SCHEMA        W_ERROR(0x00002073)
+#define WERR_DS_NO_REQUESTED_ATTS_FOUND        W_ERROR(0x00002074)
+#define WERR_DS_USER_BUFFER_TO_SMALL   W_ERROR(0x00002075)
+#define WERR_DS_ATT_IS_NOT_ON_OBJ      W_ERROR(0x00002076)
+#define WERR_DS_ILLEGAL_MOD_OPERATION  W_ERROR(0x00002077)
+#define WERR_DS_OBJ_TOO_LARGE  W_ERROR(0x00002078)
+#define WERR_DS_BAD_INSTANCE_TYPE      W_ERROR(0x00002079)
+#define WERR_DS_MASTERDSA_REQUIRED     W_ERROR(0x0000207A)
+#define WERR_DS_OBJECT_CLASS_REQUIRED  W_ERROR(0x0000207B)
+#define WERR_DS_MISSING_REQUIRED_ATT   W_ERROR(0x0000207C)
+#define WERR_DS_ATT_NOT_DEF_FOR_CLASS  W_ERROR(0x0000207D)
+#define WERR_DS_ATT_ALREADY_EXISTS     W_ERROR(0x0000207E)
+#define WERR_DS_CANT_ADD_ATT_VALUES    W_ERROR(0x00002080)
+#define WERR_DS_RANGE_CONSTRAINT       W_ERROR(0x00002082)
+#define WERR_DS_ATT_VAL_ALREADY_EXISTS W_ERROR(0x00002083)
+#define WERR_DS_CANT_REM_MISSING_ATT   W_ERROR(0x00002084)
+#define WERR_DS_CANT_REM_MISSING_ATT_VAL       W_ERROR(0x00002085)
+#define WERR_DS_ROOT_CANT_BE_SUBREF    W_ERROR(0x00002086)
+#define WERR_DS_NO_CHAINING    W_ERROR(0x00002087)
+#define WERR_DS_NO_CHAINED_EVAL        W_ERROR(0x00002088)
+#define WERR_DS_NO_PARENT_OBJECT       W_ERROR(0x00002089)
+#define WERR_DS_PARENT_IS_AN_ALIAS     W_ERROR(0x0000208A)
+#define WERR_DS_CANT_MIX_MASTER_AND_REPS       W_ERROR(0x0000208B)
+#define WERR_DS_CHILDREN_EXIST W_ERROR(0x0000208C)
+#define WERR_DS_ALIASED_OBJ_MISSING    W_ERROR(0x0000208E)
+#define WERR_DS_BAD_NAME_SYNTAX        W_ERROR(0x0000208F)
+#define WERR_DS_ALIAS_POINTS_TO_ALIAS  W_ERROR(0x00002090)
+#define WERR_DS_CANT_DEREF_ALIAS       W_ERROR(0x00002091)
+#define WERR_DS_OUT_OF_SCOPE   W_ERROR(0x00002092)
+#define WERR_DS_OBJECT_BEING_REMOVED   W_ERROR(0x00002093)
+#define WERR_DS_CANT_DELETE_DSA_OBJ    W_ERROR(0x00002094)
+#define WERR_DS_DSA_MUST_BE_INT_MASTER W_ERROR(0x00002096)
+#define WERR_DS_CLASS_NOT_DSA  W_ERROR(0x00002097)
+#define WERR_DS_ILLEGAL_SUPERIOR       W_ERROR(0x00002099)
+#define WERR_DS_ATTRIBUTE_OWNED_BY_SAM W_ERROR(0x0000209A)
+#define WERR_DS_NAME_TOO_MANY_PARTS    W_ERROR(0x0000209B)
+#define WERR_DS_NAME_TOO_LONG  W_ERROR(0x0000209C)
+#define WERR_DS_NAME_VALUE_TOO_LONG    W_ERROR(0x0000209D)
+#define WERR_DS_NAME_UNPARSEABLE       W_ERROR(0x0000209E)
+#define WERR_DS_NAME_TYPE_UNKNOWN      W_ERROR(0x0000209F)
+#define WERR_DS_NOT_AN_OBJECT  W_ERROR(0x000020A0)
+#define WERR_DS_SEC_DESC_TOO_SHORT     W_ERROR(0x000020A1)
+#define WERR_DS_SEC_DESC_INVALID       W_ERROR(0x000020A2)
+#define WERR_DS_NO_DELETED_NAME        W_ERROR(0x000020A3)
+#define WERR_DS_SUBREF_MUST_HAVE_PARENT        W_ERROR(0x000020A4)
+#define WERR_DS_NCNAME_MUST_BE_NC      W_ERROR(0x000020A5)
+#define WERR_DS_CANT_ADD_SYSTEM_ONLY   W_ERROR(0x000020A6)
+#define WERR_DS_CLASS_MUST_BE_CONCRETE W_ERROR(0x000020A7)
+#define WERR_DS_INVALID_DMD    W_ERROR(0x000020A8)
+#define WERR_DS_OBJ_GUID_EXISTS        W_ERROR(0x000020A9)
+#define WERR_DS_NOT_ON_BACKLINK        W_ERROR(0x000020AA)
+#define WERR_DS_NO_CROSSREF_FOR_NC     W_ERROR(0x000020AB)
+#define WERR_DS_SHUTTING_DOWN  W_ERROR(0x000020AC)
+#define WERR_DS_UNKNOWN_OPERATION      W_ERROR(0x000020AD)
+#define WERR_DS_INVALID_ROLE_OWNER     W_ERROR(0x000020AE)
+#define WERR_DS_COULDNT_CONTACT_FSMO   W_ERROR(0x000020AF)
+#define WERR_DS_CROSS_NC_DN_RENAME     W_ERROR(0x000020B0)
+#define WERR_DS_CANT_MOD_SYSTEM_ONLY   W_ERROR(0x000020B1)
+#define WERR_DS_REPLICATOR_ONLY        W_ERROR(0x000020B2)
+#define WERR_DS_OBJ_CLASS_NOT_DEFINED  W_ERROR(0x000020B3)
+#define WERR_DS_OBJ_CLASS_NOT_SUBCLASS W_ERROR(0x000020B4)
+#define WERR_DS_NAME_REFERENCE_INVALID W_ERROR(0x000020B5)
+#define WERR_DS_CROSS_REF_EXISTS       W_ERROR(0x000020B6)
+#define WERR_DS_CANT_DEL_MASTER_CROSSREF       W_ERROR(0x000020B7)
+#define WERR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD     W_ERROR(0x000020B8)
+#define WERR_DS_NOTIFY_FILTER_TOO_COMPLEX      W_ERROR(0x000020B9)
+#define WERR_DS_DUP_RDN        W_ERROR(0x000020BA)
+#define WERR_DS_DUP_OID        W_ERROR(0x000020BB)
+#define WERR_DS_DUP_MAPI_ID    W_ERROR(0x000020BC)
+#define WERR_DS_DUP_SCHEMA_ID_GUID     W_ERROR(0x000020BD)
+#define WERR_DS_DUP_LDAP_DISPLAY_NAME  W_ERROR(0x000020BE)
+#define WERR_DS_SEMANTIC_ATT_TEST      W_ERROR(0x000020BF)
+#define WERR_DS_SYNTAX_MISMATCH        W_ERROR(0x000020C0)
+#define WERR_DS_EXISTS_IN_MUST_HAVE    W_ERROR(0x000020C1)
+#define WERR_DS_EXISTS_IN_MAY_HAVE     W_ERROR(0x000020C2)
+#define WERR_DS_NONEXISTENT_MAY_HAVE   W_ERROR(0x000020C3)
+#define WERR_DS_NONEXISTENT_MUST_HAVE  W_ERROR(0x000020C4)
+#define WERR_DS_AUX_CLS_TEST_FAIL      W_ERROR(0x000020C5)
+#define WERR_DS_NONEXISTENT_POSS_SUP   W_ERROR(0x000020C6)
+#define WERR_DS_SUB_CLS_TEST_FAIL      W_ERROR(0x000020C7)
+#define WERR_DS_BAD_RDN_ATT_ID_SYNTAX  W_ERROR(0x000020C8)
+#define WERR_DS_EXISTS_IN_AUX_CLS      W_ERROR(0x000020C9)
+#define WERR_DS_EXISTS_IN_SUB_CLS      W_ERROR(0x000020CA)
+#define WERR_DS_EXISTS_IN_POSS_SUP     W_ERROR(0x000020CB)
+#define WERR_DS_RECALCSCHEMA_FAILED    W_ERROR(0x000020CC)
+#define WERR_DS_TREE_DELETE_NOT_FINISHED       W_ERROR(0x000020CD)
+#define WERR_DS_CANT_DELETE    W_ERROR(0x000020CE)
+#define WERR_DS_ATT_SCHEMA_REQ_ID      W_ERROR(0x000020CF)
+#define WERR_DS_BAD_ATT_SCHEMA_SYNTAX  W_ERROR(0x000020D0)
+#define WERR_DS_CANT_CACHE_ATT W_ERROR(0x000020D1)
+#define WERR_DS_CANT_CACHE_CLASS       W_ERROR(0x000020D2)
+#define WERR_DS_CANT_REMOVE_ATT_CACHE  W_ERROR(0x000020D3)
+#define WERR_DS_CANT_REMOVE_CLASS_CACHE        W_ERROR(0x000020D4)
+#define WERR_DS_CANT_RETRIEVE_DN       W_ERROR(0x000020D5)
+#define WERR_DS_MISSING_SUPREF W_ERROR(0x000020D6)
+#define WERR_DS_CANT_RETRIEVE_INSTANCE W_ERROR(0x000020D7)
+#define WERR_DS_CODE_INCONSISTENCY     W_ERROR(0x000020D8)
+#define WERR_DS_DATABASE_ERROR W_ERROR(0x000020D9)
+#define WERR_DS_MISSING_EXPECTED_ATT   W_ERROR(0x000020DB)
+#define WERR_DS_NCNAME_MISSING_CR_REF  W_ERROR(0x000020DC)
+#define WERR_DS_SECURITY_CHECKING_ERROR        W_ERROR(0x000020DD)
+#define WERR_DS_GCVERIFY_ERROR W_ERROR(0x000020E1)
+#define WERR_DS_CANT_FIND_DSA_OBJ      W_ERROR(0x000020E3)
+#define WERR_DS_CANT_FIND_EXPECTED_NC  W_ERROR(0x000020E4)
+#define WERR_DS_CANT_FIND_NC_IN_CACHE  W_ERROR(0x000020E5)
+#define WERR_DS_CANT_RETRIEVE_CHILD    W_ERROR(0x000020E6)
+#define WERR_DS_SECURITY_ILLEGAL_MODIFY        W_ERROR(0x000020E7)
+#define WERR_DS_CANT_REPLACE_HIDDEN_REC        W_ERROR(0x000020E8)
+#define WERR_DS_BAD_HIERARCHY_FILE     W_ERROR(0x000020E9)
+#define WERR_DS_BUILD_HIERARCHY_TABLE_FAILED   W_ERROR(0x000020EA)
+#define WERR_DS_CONFIG_PARAM_MISSING   W_ERROR(0x000020EB)
+#define WERR_DS_COUNTING_AB_INDICES_FAILED     W_ERROR(0x000020EC)
+#define WERR_DS_HIERARCHY_TABLE_MALLOC_FAILED  W_ERROR(0x000020ED)
+#define WERR_DS_INTERNAL_FAILURE       W_ERROR(0x000020EE)
+#define WERR_DS_UNKNOWN_ERROR  W_ERROR(0x000020EF)
+#define WERR_DS_ROOT_REQUIRES_CLASS_TOP        W_ERROR(0x000020F0)
+#define WERR_DS_REFUSING_FSMO_ROLES    W_ERROR(0x000020F1)
+#define WERR_DS_MISSING_FSMO_SETTINGS  W_ERROR(0x000020F2)
+#define WERR_DS_UNABLE_TO_SURRENDER_ROLES      W_ERROR(0x000020F3)
+#define WERR_DS_DRA_GENERIC    W_ERROR(0x000020F4)
+#define WERR_DS_DRA_BUSY       W_ERROR(0x000020F6)
+#define WERR_DS_DRA_DN_EXISTS  W_ERROR(0x000020F9)
+#define WERR_DS_DRA_INCONSISTENT_DIT   W_ERROR(0x000020FB)
+#define WERR_DS_DRA_CONNECTION_FAILED  W_ERROR(0x000020FC)
+#define WERR_DS_DRA_BAD_INSTANCE_TYPE  W_ERROR(0x000020FD)
+#define WERR_DS_DRA_MAIL_PROBLEM       W_ERROR(0x000020FF)
+#define WERR_DS_DRA_REF_ALREADY_EXISTS W_ERROR(0x00002100)
+#define WERR_DS_DRA_REF_NOT_FOUND      W_ERROR(0x00002101)
+#define WERR_DS_DRA_OBJ_IS_REP_SOURCE  W_ERROR(0x00002102)
+#define WERR_DS_DRA_NOT_SUPPORTED      W_ERROR(0x00002106)
+#define WERR_DS_DRA_RPC_CANCELLED      W_ERROR(0x00002107)
+#define WERR_DS_DRA_SINK_DISABLED      W_ERROR(0x00002109)
+#define WERR_DS_DRA_NAME_COLLISION     W_ERROR(0x0000210A)
+#define WERR_DS_DRA_SOURCE_REINSTALLED W_ERROR(0x0000210B)
+#define WERR_DS_DRA_MISSING_PARENT     W_ERROR(0x0000210C)
+#define WERR_DS_DRA_PREEMPTED  W_ERROR(0x0000210D)
+#define WERR_DS_DRA_ABANDON_SYNC       W_ERROR(0x0000210E)
+#define WERR_DS_DRA_SHUTDOWN   W_ERROR(0x0000210F)
+#define WERR_DS_DRA_INCOMPATIBLE_PARTIAL_SET   W_ERROR(0x00002110)
+#define WERR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA  W_ERROR(0x00002111)
+#define WERR_DS_DRA_EXTN_CONNECTION_FAILED     W_ERROR(0x00002112)
+#define WERR_DS_INSTALL_SCHEMA_MISMATCH        W_ERROR(0x00002113)
+#define WERR_DS_DUP_LINK_ID    W_ERROR(0x00002114)
+#define WERR_DS_NAME_ERROR_RESOLVING   W_ERROR(0x00002115)
+#define WERR_DS_NAME_ERROR_NOT_FOUND   W_ERROR(0x00002116)
+#define WERR_DS_NAME_ERROR_NOT_UNIQUE  W_ERROR(0x00002117)
+#define WERR_DS_NAME_ERROR_NO_MAPPING  W_ERROR(0x00002118)
+#define WERR_DS_NAME_ERROR_DOMAIN_ONLY W_ERROR(0x00002119)
+#define WERR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING      W_ERROR(0x0000211A)
+#define WERR_DS_CONSTRUCTED_ATT_MOD    W_ERROR(0x0000211B)
+#define WERR_DS_WRONG_OM_OBJ_CLASS     W_ERROR(0x0000211C)
+#define WERR_DS_DRA_REPL_PENDING       W_ERROR(0x0000211D)
+#define WERR_DS_DS_REQUIRED    W_ERROR(0x0000211E)
+#define WERR_DS_INVALID_LDAP_DISPLAY_NAME      W_ERROR(0x0000211F)
+#define WERR_DS_NON_BASE_SEARCH        W_ERROR(0x00002120)
+#define WERR_DS_CANT_RETRIEVE_ATTS     W_ERROR(0x00002121)
+#define WERR_DS_BACKLINK_WITHOUT_LINK  W_ERROR(0x00002122)
+#define WERR_DS_EPOCH_MISMATCH W_ERROR(0x00002123)
+#define WERR_DS_SRC_NAME_MISMATCH      W_ERROR(0x00002124)
+#define WERR_DS_SRC_AND_DST_NC_IDENTICAL       W_ERROR(0x00002125)
+#define WERR_DS_DST_NC_MISMATCH        W_ERROR(0x00002126)
+#define WERR_DS_NOT_AUTHORITIVE_FOR_DST_NC     W_ERROR(0x00002127)
+#define WERR_DS_SRC_GUID_MISMATCH      W_ERROR(0x00002128)
+#define WERR_DS_CANT_MOVE_DELETED_OBJECT       W_ERROR(0x00002129)
+#define WERR_DS_PDC_OPERATION_IN_PROGRESS      W_ERROR(0x0000212A)
+#define WERR_DS_CROSS_DOMAIN_CLEANUP_REQD      W_ERROR(0x0000212B)
+#define WERR_DS_ILLEGAL_XDOM_MOVE_OPERATION    W_ERROR(0x0000212C)
+#define WERR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS        W_ERROR(0x0000212D)
+#define WERR_DS_NC_MUST_HAVE_NC_PARENT W_ERROR(0x0000212E)
+#define WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE      W_ERROR(0x0000212F)
+#define WERR_DS_DST_DOMAIN_NOT_NATIVE  W_ERROR(0x00002130)
+#define WERR_DS_MISSING_INFRASTRUCTURE_CONTAINER       W_ERROR(0x00002131)
+#define WERR_DS_CANT_MOVE_ACCOUNT_GROUP        W_ERROR(0x00002132)
+#define WERR_DS_CANT_MOVE_RESOURCE_GROUP       W_ERROR(0x00002133)
+#define WERR_DS_INVALID_SEARCH_FLAG    W_ERROR(0x00002134)
+#define WERR_DS_NO_TREE_DELETE_ABOVE_NC        W_ERROR(0x00002135)
+#define WERR_DS_COULDNT_LOCK_TREE_FOR_DELETE   W_ERROR(0x00002136)
+#define WERR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE       W_ERROR(0x00002137)
+#define WERR_DS_SAM_INIT_FAILURE       W_ERROR(0x00002138)
+#define WERR_DS_SENSITIVE_GROUP_VIOLATION      W_ERROR(0x00002139)
+#define WERR_DS_CANT_MOD_PRIMARYGROUPID        W_ERROR(0x0000213A)
+#define WERR_DS_ILLEGAL_BASE_SCHEMA_MOD        W_ERROR(0x0000213B)
+#define WERR_DS_NONSAFE_SCHEMA_CHANGE  W_ERROR(0x0000213C)
+#define WERR_DS_SCHEMA_UPDATE_DISALLOWED       W_ERROR(0x0000213D)
+#define WERR_DS_CANT_CREATE_UNDER_SCHEMA       W_ERROR(0x0000213E)
+#define WERR_DS_INVALID_GROUP_TYPE     W_ERROR(0x00002141)
+#define WERR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN     W_ERROR(0x00002142)
+#define WERR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN      W_ERROR(0x00002143)
+#define WERR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER  W_ERROR(0x00002144)
+#define WERR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER      W_ERROR(0x00002145)
+#define WERR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER       W_ERROR(0x00002146)
+#define WERR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER    W_ERROR(0x00002147)
+#define WERR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER       W_ERROR(0x00002148)
+#define WERR_DS_HAVE_PRIMARY_MEMBERS   W_ERROR(0x00002149)
+#define WERR_DS_STRING_SD_CONVERSION_FAILED    W_ERROR(0x0000214A)
+#define WERR_DS_NAMING_MASTER_GC       W_ERROR(0x0000214B)
+#define WERR_DS_COULDNT_UPDATE_SPNS    W_ERROR(0x0000214D)
+#define WERR_DS_CANT_RETRIEVE_SD       W_ERROR(0x0000214E)
+#define WERR_DS_KEY_NOT_UNIQUE W_ERROR(0x0000214F)
+#define WERR_DS_WRONG_LINKED_ATT_SYNTAX        W_ERROR(0x00002150)
+#define WERR_DS_SAM_NEED_BOOTKEY_PASSWORD      W_ERROR(0x00002151)
+#define WERR_DS_SAM_NEED_BOOTKEY_FLOPPY        W_ERROR(0x00002152)
+#define WERR_DS_CANT_START     W_ERROR(0x00002153)
+#define WERR_DS_INIT_FAILURE   W_ERROR(0x00002154)
+#define WERR_DS_NO_PKT_PRIVACY_ON_CONNECTION   W_ERROR(0x00002155)
+#define WERR_DS_SOURCE_DOMAIN_IN_FOREST        W_ERROR(0x00002156)
+#define WERR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST       W_ERROR(0x00002157)
+#define WERR_DS_DESTINATION_AUDITING_NOT_ENABLED       W_ERROR(0x00002158)
+#define WERR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN    W_ERROR(0x00002159)
+#define WERR_DS_SRC_OBJ_NOT_GROUP_OR_USER      W_ERROR(0x0000215A)
+#define WERR_DS_SRC_SID_EXISTS_IN_FOREST       W_ERROR(0x0000215B)
+#define WERR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH      W_ERROR(0x0000215C)
+#define WERR_SAM_INIT_FAILURE  W_ERROR(0x0000215D)
+#define WERR_DS_DRA_SCHEMA_INFO_SHIP   W_ERROR(0x0000215E)
+#define WERR_DS_DRA_SCHEMA_CONFLICT    W_ERROR(0x0000215F)
+#define WERR_DS_DRA_EARLIER_SCHEMA_CONFLICT    W_ERROR(0x00002160)
+#define WERR_DS_DRA_OBJ_NC_MISMATCH    W_ERROR(0x00002161)
+#define WERR_DS_NC_STILL_HAS_DSAS      W_ERROR(0x00002162)
+#define WERR_DS_GC_REQUIRED    W_ERROR(0x00002163)
+#define WERR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY     W_ERROR(0x00002164)
+#define WERR_DS_NO_FPO_IN_UNIVERSAL_GROUPS     W_ERROR(0x00002165)
+#define WERR_DS_CANT_ADD_TO_GC W_ERROR(0x00002166)
+#define WERR_DS_NO_CHECKPOINT_WITH_PDC W_ERROR(0x00002167)
+#define WERR_DS_SOURCE_AUDITING_NOT_ENABLED    W_ERROR(0x00002168)
+#define WERR_DS_CANT_CREATE_IN_NONDOMAIN_NC    W_ERROR(0x00002169)
+#define WERR_DS_INVALID_NAME_FOR_SPN   W_ERROR(0x0000216A)
+#define WERR_DS_FILTER_USES_CONTRUCTED_ATTRS   W_ERROR(0x0000216B)
+#define WERR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED W_ERROR(0x0000216D)
+#define WERR_DS_MUST_BE_RUN_ON_DST_DC  W_ERROR(0x0000216E)
+#define WERR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER  W_ERROR(0x0000216F)
+#define WERR_DS_CANT_TREE_DELETE_CRITICAL_OBJ  W_ERROR(0x00002170)
+#define WERR_DS_INIT_FAILURE_CONSOLE   W_ERROR(0x00002171)
+#define WERR_DS_SAM_INIT_FAILURE_CONSOLE       W_ERROR(0x00002172)
+#define WERR_DS_FOREST_VERSION_TOO_HIGH        W_ERROR(0x00002173)
+#define WERR_DS_DOMAIN_VERSION_TOO_HIGH        W_ERROR(0x00002174)
+#define WERR_DS_FOREST_VERSION_TOO_LOW W_ERROR(0x00002175)
+#define WERR_DS_DOMAIN_VERSION_TOO_LOW W_ERROR(0x00002176)
+#define WERR_DS_INCOMPATIBLE_VERSION   W_ERROR(0x00002177)
+#define WERR_DS_LOW_DSA_VERSION        W_ERROR(0x00002178)
+#define WERR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN     W_ERROR(0x00002179)
+#define WERR_DS_NOT_SUPPORTED_SORT_ORDER       W_ERROR(0x0000217A)
+#define WERR_DS_NAME_NOT_UNIQUE        W_ERROR(0x0000217B)
+#define WERR_DS_MACHINE_ACCOUNT_CREATED_PRENT4 W_ERROR(0x0000217C)
+#define WERR_DS_OUT_OF_VERSION_STORE   W_ERROR(0x0000217D)
+#define WERR_DS_INCOMPATIBLE_CONTROLS_USED     W_ERROR(0x0000217E)
+#define WERR_DS_NO_REF_DOMAIN  W_ERROR(0x0000217F)
+#define WERR_DS_RESERVED_LINK_ID       W_ERROR(0x00002180)
+#define WERR_DS_LINK_ID_NOT_AVAILABLE  W_ERROR(0x00002181)
+#define WERR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER  W_ERROR(0x00002182)
+#define WERR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE   W_ERROR(0x00002183)
+#define WERR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC    W_ERROR(0x00002184)
+#define WERR_DS_MODIFYDN_DISALLOWED_BY_FLAG    W_ERROR(0x00002185)
+#define WERR_DS_MODIFYDN_WRONG_GRANDPARENT     W_ERROR(0x00002186)
+#define WERR_DS_NAME_ERROR_TRUST_REFERRAL      W_ERROR(0x00002187)
+#define WERR_NOT_SUPPORTED_ON_STANDARD_SERVER  W_ERROR(0x00002188)
+#define WERR_DS_CANT_ACCESS_REMOTE_PART_OF_AD  W_ERROR(0x00002189)
+#define WERR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2   W_ERROR(0x0000218A)
+#define WERR_DS_THREAD_LIMIT_EXCEEDED  W_ERROR(0x0000218B)
+#define WERR_DS_NOT_CLOSEST    W_ERROR(0x0000218C)
+#define WERR_DS_SINGLE_USER_MODE_FAILED        W_ERROR(0x0000218E)
+#define WERR_DS_NTDSCRIPT_SYNTAX_ERROR W_ERROR(0x0000218F)
+#define WERR_DS_NTDSCRIPT_PROCESS_ERROR        W_ERROR(0x00002190)
+#define WERR_DS_DIFFERENT_REPL_EPOCHS  W_ERROR(0x00002191)
+#define WERR_DS_DRS_EXTENSIONS_CHANGED W_ERROR(0x00002192)
+#define WERR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR  W_ERROR(0x00002193)
+#define WERR_DS_EXISTS_IN_RDNATTID     W_ERROR(0x00002196)
+#define WERR_DS_AUTHORIZATION_FAILED   W_ERROR(0x00002197)
+#define WERR_DS_INVALID_SCRIPT W_ERROR(0x00002198)
+#define WERR_DS_REMOTE_CROSSREF_OP_FAILED      W_ERROR(0x00002199)
+#define WERR_DS_CROSS_REF_BUSY W_ERROR(0x0000219A)
+#define WERR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN     W_ERROR(0x0000219B)
+#define WERR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC  W_ERROR(0x0000219C)
+#define WERR_DS_DUPLICATE_ID_FOUND     W_ERROR(0x0000219D)
+#define WERR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT     W_ERROR(0x0000219E)
+#define WERR_DS_GROUP_CONVERSION_ERROR W_ERROR(0x0000219F)
+#define WERR_DS_CANT_MOVE_APP_BASIC_GROUP      W_ERROR(0x000021A0)
+#define WERR_DS_CANT_MOVE_APP_QUERY_GROUP      W_ERROR(0x000021A1)
+#define WERR_DS_ROLE_NOT_VERIFIED      W_ERROR(0x000021A2)
+#define WERR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL        W_ERROR(0x000021A3)
+#define WERR_DS_DOMAIN_RENAME_IN_PROGRESS      W_ERROR(0x000021A4)
+#define WERR_DS_EXISTING_AD_CHILD_NC   W_ERROR(0x000021A5)
+#define WERR_DS_REPL_LIFETIME_EXCEEDED W_ERROR(0x000021A6)
+#define WERR_DS_DISALLOWED_IN_SYSTEM_CONTAINER W_ERROR(0x000021A7)
+#define WERR_DS_LDAP_SEND_QUEUE_FULL   W_ERROR(0x000021A8)
+#define WERR_DS_DRA_OUT_SCHEDULE_WINDOW        W_ERROR(0x000021A9)
+#define WERR_DS_POLICY_NOT_KNOWN       W_ERROR(0x000021AA)
+#define WERR_NO_SITE_SETTINGS_OBJECT   W_ERROR(0x000021AB)
+#define WERR_NO_SECRETS        W_ERROR(0x000021AC)
+#define WERR_NO_WRITABLE_DC_FOUND      W_ERROR(0x000021AD)
+#define WERR_DS_NO_SERVER_OBJECT       W_ERROR(0x000021AE)
+#define WERR_DS_NO_NTDSA_OBJECT        W_ERROR(0x000021AF)
+#define WERR_DS_NON_ASQ_SEARCH W_ERROR(0x000021B0)
+#define WERR_DS_AUDIT_FAILURE  W_ERROR(0x000021B1)
+#define WERR_DS_INVALID_SEARCH_FLAG_SUBTREE    W_ERROR(0x000021B2)
+#define WERR_DS_INVALID_SEARCH_FLAG_TUPLE      W_ERROR(0x000021B3)
+#define WERR_IPSEC_QM_POLICY_EXISTS    W_ERROR(0x000032C8)
+#define WERR_IPSEC_QM_POLICY_NOT_FOUND W_ERROR(0x000032C9)
+#define WERR_IPSEC_QM_POLICY_IN_USE    W_ERROR(0x000032CA)
+#define WERR_IPSEC_MM_POLICY_EXISTS    W_ERROR(0x000032CB)
+#define WERR_IPSEC_MM_POLICY_NOT_FOUND W_ERROR(0x000032CC)
+#define WERR_IPSEC_MM_POLICY_IN_USE    W_ERROR(0x000032CD)
+#define WERR_IPSEC_MM_FILTER_EXISTS    W_ERROR(0x000032CE)
+#define WERR_IPSEC_MM_FILTER_NOT_FOUND W_ERROR(0x000032CF)
+#define WERR_IPSEC_TRANSPORT_FILTER_EXISTS     W_ERROR(0x000032D0)
+#define WERR_IPSEC_TRANSPORT_FILTER_NOT_FOUND  W_ERROR(0x000032D1)
+#define WERR_IPSEC_MM_AUTH_EXISTS      W_ERROR(0x000032D2)
+#define WERR_IPSEC_MM_AUTH_NOT_FOUND   W_ERROR(0x000032D3)
+#define WERR_IPSEC_MM_AUTH_IN_USE      W_ERROR(0x000032D4)
+#define WERR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND W_ERROR(0x000032D5)
+#define WERR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND   W_ERROR(0x000032D6)
+#define WERR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND W_ERROR(0x000032D7)
+#define WERR_IPSEC_TUNNEL_FILTER_EXISTS        W_ERROR(0x000032D8)
+#define WERR_IPSEC_TUNNEL_FILTER_NOT_FOUND     W_ERROR(0x000032D9)
+#define WERR_IPSEC_MM_FILTER_PENDING_DELETION  W_ERROR(0x000032DA)
+#define WERR_IPSEC_TRANSPORT_FILTER_ENDING_DELETION    W_ERROR(0x000032DB)
+#define WERR_IPSEC_TUNNEL_FILTER_PENDING_DELETION      W_ERROR(0x000032DC)
+#define WERR_IPSEC_MM_POLICY_PENDING_ELETION   W_ERROR(0x000032DD)
+#define WERR_IPSEC_MM_AUTH_PENDING_DELETION    W_ERROR(0x000032DE)
+#define WERR_IPSEC_QM_POLICY_PENDING_DELETION  W_ERROR(0x000032DF)
+#define WERR_IPSEC_IKE_NEG_STATUS_BEGIN        W_ERROR(0x000035E8)
+#define WERR_IPSEC_IKE_AUTH_FAIL       W_ERROR(0x000035E9)
+#define WERR_IPSEC_IKE_ATTRIB_FAIL     W_ERROR(0x000035EA)
+#define WERR_IPSEC_IKE_NEGOTIATION_PENDING     W_ERROR(0x000035EB)
+#define WERR_IPSEC_IKE_GENERAL_PROCESSING_ERROR        W_ERROR(0x000035EC)
+#define WERR_IPSEC_IKE_TIMED_OUT       W_ERROR(0x000035ED)
+#define WERR_IPSEC_IKE_NO_CERT W_ERROR(0x000035EE)
+#define WERR_IPSEC_IKE_SA_DELETED      W_ERROR(0x000035EF)
+#define WERR_IPSEC_IKE_SA_REAPED       W_ERROR(0x000035F0)
+#define WERR_IPSEC_IKE_MM_ACQUIRE_DROP W_ERROR(0x000035F1)
+#define WERR_IPSEC_IKE_QM_ACQUIRE_DROP W_ERROR(0x000035F2)
+#define WERR_IPSEC_IKE_QUEUE_DROP_MM   W_ERROR(0x000035F3)
+#define WERR_IPSEC_IKE_QUEUE_DROP_NO_MM        W_ERROR(0x000035F4)
+#define WERR_IPSEC_IKE_DROP_NO_RESPONSE        W_ERROR(0x000035F5)
+#define WERR_IPSEC_IKE_MM_DELAY_DROP   W_ERROR(0x000035F6)
+#define WERR_IPSEC_IKE_QM_DELAY_DROP   W_ERROR(0x000035F7)
+#define WERR_IPSEC_IKE_ERROR   W_ERROR(0x000035F8)
+#define WERR_IPSEC_IKE_CRL_FAILED      W_ERROR(0x000035F9)
+#define WERR_IPSEC_IKE_INVALID_KEY_USAGE       W_ERROR(0x000035FA)
+#define WERR_IPSEC_IKE_INVALID_CERT_TYPE       W_ERROR(0x000035FB)
+#define WERR_IPSEC_IKE_NO_PRIVATE_KEY  W_ERROR(0x000035FC)
+#define WERR_IPSEC_IKE_DH_FAIL W_ERROR(0x000035FE)
+#define WERR_IPSEC_IKE_INVALID_HEADER  W_ERROR(0x00003600)
+#define WERR_IPSEC_IKE_NO_POLICY       W_ERROR(0x00003601)
+#define WERR_IPSEC_IKE_INVALID_SIGNATURE       W_ERROR(0x00003602)
+#define WERR_IPSEC_IKE_KERBEROS_ERROR  W_ERROR(0x00003603)
+#define WERR_IPSEC_IKE_NO_PUBLIC_KEY   W_ERROR(0x00003604)
+#define WERR_IPSEC_IKE_PROCESS_ERR     W_ERROR(0x00003605)
+#define WERR_IPSEC_IKE_PROCESS_ERR_SA  W_ERROR(0x00003606)
+#define WERR_IPSEC_IKE_PROCESS_ERR_PROP        W_ERROR(0x00003607)
+#define WERR_IPSEC_IKE_PROCESS_ERR_TRANS       W_ERROR(0x00003608)
+#define WERR_IPSEC_IKE_PROCESS_ERR_KE  W_ERROR(0x00003609)
+#define WERR_IPSEC_IKE_PROCESS_ERR_ID  W_ERROR(0x0000360A)
+#define WERR_IPSEC_IKE_PROCESS_ERR_CERT        W_ERROR(0x0000360B)
+#define WERR_IPSEC_IKE_PROCESS_ERR_CERT_REQ    W_ERROR(0x0000360C)
+#define WERR_IPSEC_IKE_PROCESS_ERR_HASH        W_ERROR(0x0000360D)
+#define WERR_IPSEC_IKE_PROCESS_ERR_SIG W_ERROR(0x0000360E)
+#define WERR_IPSEC_IKE_PROCESS_ERR_NONCE       W_ERROR(0x0000360F)
+#define WERR_IPSEC_IKE_PROCESS_ERR_NOTIFY      W_ERROR(0x00003610)
+#define WERR_IPSEC_IKE_PROCESS_ERR_DELETE      W_ERROR(0x00003611)
+#define WERR_IPSEC_IKE_PROCESS_ERR_VENDOR      W_ERROR(0x00003612)
+#define WERR_IPSEC_IKE_INVALID_PAYLOAD W_ERROR(0x00003613)
+#define WERR_IPSEC_IKE_LOAD_SOFT_SA    W_ERROR(0x00003614)
+#define WERR_IPSEC_IKE_SOFT_SA_TORN_DOWN       W_ERROR(0x00003615)
+#define WERR_IPSEC_IKE_INVALID_COOKIE  W_ERROR(0x00003616)
+#define WERR_IPSEC_IKE_NO_PEER_CERT    W_ERROR(0x00003617)
+#define WERR_IPSEC_IKE_PEER_CRL_FAILED W_ERROR(0x00003618)
+#define WERR_IPSEC_IKE_POLICY_CHANGE   W_ERROR(0x00003619)
+#define WERR_IPSEC_IKE_NO_MM_POLICY    W_ERROR(0x0000361A)
+#define WERR_IPSEC_IKE_NOTCBPRIV       W_ERROR(0x0000361B)
+#define WERR_IPSEC_IKE_SECLOADFAIL     W_ERROR(0x0000361C)
+#define WERR_IPSEC_IKE_FAILSSPINIT     W_ERROR(0x0000361D)
+#define WERR_IPSEC_IKE_FAILQUERYSSP    W_ERROR(0x0000361E)
+#define WERR_IPSEC_IKE_SRVACQFAIL      W_ERROR(0x0000361F)
+#define WERR_IPSEC_IKE_SRVQUERYCRED    W_ERROR(0x00003620)
+#define WERR_IPSEC_IKE_GETSPIFAIL      W_ERROR(0x00003621)
+#define WERR_IPSEC_IKE_INVALID_FILTER  W_ERROR(0x00003622)
+#define WERR_IPSEC_IKE_OUT_OF_MEMORY   W_ERROR(0x00003623)
+#define WERR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED   W_ERROR(0x00003624)
+#define WERR_IPSEC_IKE_INVALID_POLICY  W_ERROR(0x00003625)
+#define WERR_IPSEC_IKE_UNKNOWN_DOI     W_ERROR(0x00003626)
+#define WERR_IPSEC_IKE_INVALID_SITUATION       W_ERROR(0x00003627)
+#define WERR_IPSEC_IKE_DH_FAILURE      W_ERROR(0x00003628)
+#define WERR_IPSEC_IKE_INVALID_GROUP   W_ERROR(0x00003629)
+#define WERR_IPSEC_IKE_ENCRYPT W_ERROR(0x0000362A)
+#define WERR_IPSEC_IKE_DECRYPT W_ERROR(0x0000362B)
+#define WERR_IPSEC_IKE_POLICY_MATCH    W_ERROR(0x0000362C)
+#define WERR_IPSEC_IKE_UNSUPPORTED_ID  W_ERROR(0x0000362D)
+#define WERR_IPSEC_IKE_INVALID_HASH    W_ERROR(0x0000362E)
+#define WERR_IPSEC_IKE_INVALID_HASH_ALG        W_ERROR(0x0000362F)
+#define WERR_IPSEC_IKE_INVALID_HASH_SIZE       W_ERROR(0x00003630)
+#define WERR_IPSEC_IKE_INVALID_ENCRYPT_ALG     W_ERROR(0x00003631)
+#define WERR_IPSEC_IKE_INVALID_AUTH_ALG        W_ERROR(0x00003632)
+#define WERR_IPSEC_IKE_INVALID_SIG     W_ERROR(0x00003633)
+#define WERR_IPSEC_IKE_LOAD_FAILED     W_ERROR(0x00003634)
+#define WERR_IPSEC_IKE_RPC_DELETE      W_ERROR(0x00003635)
+#define WERR_IPSEC_IKE_BENIGN_REINIT   W_ERROR(0x00003636)
+#define WERR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY       W_ERROR(0x00003637)
+#define WERR_IPSEC_IKE_INVALID_CERT_KEYLEN     W_ERROR(0x00003639)
+#define WERR_IPSEC_IKE_MM_LIMIT        W_ERROR(0x0000363A)
+#define WERR_IPSEC_IKE_NEGOTIATION_DISABLED    W_ERROR(0x0000363B)
+#define WERR_IPSEC_IKE_QM_LIMIT        W_ERROR(0x0000363C)
+#define WERR_IPSEC_IKE_MM_EXPIRED      W_ERROR(0x0000363D)
+#define WERR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID W_ERROR(0x0000363E)
+#define WERR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH      W_ERROR(0x0000363F)
+#define WERR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID   W_ERROR(0x00003640)
+#define WERR_IPSEC_IKE_INVALID_UMATTS  W_ERROR(0x00003641)
+#define WERR_IPSEC_IKE_DOS_COOKIE_SENT W_ERROR(0x00003642)
+#define WERR_IPSEC_IKE_SHUTTING_DOWN   W_ERROR(0x00003643)
+#define WERR_IPSEC_IKE_CGA_AUTH_FAILED W_ERROR(0x00003644)
+#define WERR_IPSEC_IKE_PROCESS_ERR_NATOA       W_ERROR(0x00003645)
+#define WERR_IPSEC_IKE_INVALID_MM_FOR_QM       W_ERROR(0x00003646)
+#define WERR_IPSEC_IKE_QM_EXPIRED      W_ERROR(0x00003647)
+#define WERR_IPSEC_IKE_TOO_MANY_FILTERS        W_ERROR(0x00003648)
+#define WERR_IPSEC_IKE_NEG_STATUS_END  W_ERROR(0x00003649)
+#define WERR_SXS_SECTION_NOT_FOUND     W_ERROR(0x000036B0)
+#define WERR_SXS_CANT_GEN_ACTCTX       W_ERROR(0x000036B1)
+#define WERR_SXS_INVALID_ACTCTXDATA_FORMAT     W_ERROR(0x000036B2)
+#define WERR_SXS_ASSEMBLY_NOT_FOUND    W_ERROR(0x000036B3)
+#define WERR_SXS_MANIFEST_FORMAT_ERROR W_ERROR(0x000036B4)
+#define WERR_SXS_MANIFEST_PARSE_ERROR  W_ERROR(0x000036B5)
+#define WERR_SXS_ACTIVATION_CONTEXT_DISABLED   W_ERROR(0x000036B6)
+#define WERR_SXS_KEY_NOT_FOUND W_ERROR(0x000036B7)
+#define WERR_SXS_VERSION_CONFLICT      W_ERROR(0x000036B8)
+#define WERR_SXS_WRONG_SECTION_TYPE    W_ERROR(0x000036B9)
+#define WERR_SXS_THREAD_QUERIES_DISABLED       W_ERROR(0x000036BA)
+#define WERR_SXS_PROCESS_DEFAULT_ALREADY_SET   W_ERROR(0x000036BB)
+#define WERR_SXS_UNKNOWN_ENCODING_GROUP        W_ERROR(0x000036BC)
+#define WERR_SXS_UNKNOWN_ENCODING      W_ERROR(0x000036BD)
+#define WERR_SXS_INVALID_XML_NAMESPACE_URI     W_ERROR(0x000036BE)
+#define WERR_SXS_ROOT_MANIFEST_DEPENDENCY_OT_INSTALLED W_ERROR(0x000036BF)
+#define WERR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED        W_ERROR(0x000036C0)
+#define WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE   W_ERROR(0x000036C1)
+#define WERR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE   W_ERROR(0x000036C2)
+#define WERR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE   W_ERROR(0x000036C3)
+#define WERR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT        W_ERROR(0x000036C4)
+#define WERR_SXS_DUPLICATE_DLL_NAME    W_ERROR(0x000036C5)
+#define WERR_SXS_DUPLICATE_WINDOWCLASS_NAME    W_ERROR(0x000036C6)
+#define WERR_SXS_DUPLICATE_CLSID       W_ERROR(0x000036C7)
+#define WERR_SXS_DUPLICATE_IID W_ERROR(0x000036C8)
+#define WERR_SXS_DUPLICATE_TLBID       W_ERROR(0x000036C9)
+#define WERR_SXS_DUPLICATE_PROGID      W_ERROR(0x000036CA)
+#define WERR_SXS_DUPLICATE_ASSEMBLY_NAME       W_ERROR(0x000036CB)
+#define WERR_SXS_FILE_HASH_MISMATCH    W_ERROR(0x000036CC)
+#define WERR_SXS_POLICY_PARSE_ERROR    W_ERROR(0x000036CD)
+#define WERR_SXS_XML_E_MISSINGQUOTE    W_ERROR(0x000036CE)
+#define WERR_SXS_XML_E_COMMENTSYNTAX   W_ERROR(0x000036CF)
+#define WERR_SXS_XML_E_BADSTARTNAMECHAR        W_ERROR(0x000036D0)
+#define WERR_SXS_XML_E_BADNAMECHAR     W_ERROR(0x000036D1)
+#define WERR_SXS_XML_E_BADCHARINSTRING W_ERROR(0x000036D2)
+#define WERR_SXS_XML_E_XMLDECLSYNTAX   W_ERROR(0x000036D3)
+#define WERR_SXS_XML_E_BADCHARDATA     W_ERROR(0x000036D4)
+#define WERR_SXS_XML_E_MISSINGWHITESPACE       W_ERROR(0x000036D5)
+#define WERR_SXS_XML_E_EXPECTINGTAGEND W_ERROR(0x000036D6)
+#define WERR_SXS_XML_E_MISSINGSEMICOLON        W_ERROR(0x000036D7)
+#define WERR_SXS_XML_E_UNBALANCEDPAREN W_ERROR(0x000036D8)
+#define WERR_SXS_XML_E_INTERNALERROR   W_ERROR(0x000036D9)
+#define WERR_SXS_XML_E_UNEXPECTED_WHITESPACE   W_ERROR(0x000036DA)
+#define WERR_SXS_XML_E_INCOMPLETE_ENCODING     W_ERROR(0x000036DB)
+#define WERR_SXS_XML_E_MISSING_PAREN   W_ERROR(0x000036DC)
+#define WERR_SXS_XML_E_EXPECTINGCLOSEQUOTE     W_ERROR(0x000036DD)
+#define WERR_SXS_XML_E_MULTIPLE_COLONS W_ERROR(0x000036DE)
+#define WERR_SXS_XML_E_INVALID_DECIMAL W_ERROR(0x000036DF)
+#define WERR_SXS_XML_E_INVALID_HEXIDECIMAL     W_ERROR(0x000036E0)
+#define WERR_SXS_XML_E_INVALID_UNICODE W_ERROR(0x000036E1)
+#define WERR_SXS_XML_E_WHITESPACEORQUESTIONMARK        W_ERROR(0x000036E2)
+#define WERR_SXS_XML_E_UNEXPECTEDENDTAG        W_ERROR(0x000036E3)
+#define WERR_SXS_XML_E_UNCLOSEDTAG     W_ERROR(0x000036E4)
+#define WERR_SXS_XML_E_DUPLICATEATTRIBUTE      W_ERROR(0x000036E5)
+#define WERR_SXS_XML_E_MULTIPLEROOTS   W_ERROR(0x000036E6)
+#define WERR_SXS_XML_E_INVALIDATROOTLEVEL      W_ERROR(0x000036E7)
+#define WERR_SXS_XML_E_BADXMLDECL      W_ERROR(0x000036E8)
+#define WERR_SXS_XML_E_MISSINGROOT     W_ERROR(0x000036E9)
+#define WERR_SXS_XML_E_UNEXPECTEDEOF   W_ERROR(0x000036EA)
+#define WERR_SXS_XML_E_BADPEREFINSUBSET        W_ERROR(0x000036EB)
+#define WERR_SXS_XML_E_UNCLOSEDSTARTTAG        W_ERROR(0x000036EC)
+#define WERR_SXS_XML_E_UNCLOSEDENDTAG  W_ERROR(0x000036ED)
+#define WERR_SXS_XML_E_UNCLOSEDSTRING  W_ERROR(0x000036EE)
+#define WERR_SXS_XML_E_UNCLOSEDCOMMENT W_ERROR(0x000036EF)
+#define WERR_SXS_XML_E_UNCLOSEDDECL    W_ERROR(0x000036F0)
+#define WERR_SXS_XML_E_UNCLOSEDCDATA   W_ERROR(0x000036F1)
+#define WERR_SXS_XML_E_RESERVEDNAMESPACE       W_ERROR(0x000036F2)
+#define WERR_SXS_XML_E_INVALIDENCODING W_ERROR(0x000036F3)
+#define WERR_SXS_XML_E_INVALIDSWITCH   W_ERROR(0x000036F4)
+#define WERR_SXS_XML_E_BADXMLCASE      W_ERROR(0x000036F5)
+#define WERR_SXS_XML_E_INVALID_STANDALONE      W_ERROR(0x000036F6)
+#define WERR_SXS_XML_E_UNEXPECTED_STANDALONE   W_ERROR(0x000036F7)
+#define WERR_SXS_XML_E_INVALID_VERSION W_ERROR(0x000036F8)
+#define WERR_SXS_XML_E_MISSINGEQUALS   W_ERROR(0x000036F9)
+#define WERR_SXS_PROTECTION_RECOVERY_FAILED    W_ERROR(0x000036FA)
+#define WERR_SXS_PROTECTION_PUBLIC_KEY_OO_SHORT        W_ERROR(0x000036FB)
+#define WERR_SXS_PROTECTION_CATALOG_NOT_VALID  W_ERROR(0x000036FC)
+#define WERR_SXS_UNTRANSLATABLE_HRESULT        W_ERROR(0x000036FD)
+#define WERR_SXS_PROTECTION_CATALOG_FILE_MISSING       W_ERROR(0x000036FE)
+#define WERR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE   W_ERROR(0x000036FF)
+#define WERR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME      W_ERROR(0x00003700)
+#define WERR_SXS_ASSEMBLY_MISSING      W_ERROR(0x00003701)
+#define WERR_SXS_CORRUPT_ACTIVATION_STACK      W_ERROR(0x00003702)
+#define WERR_SXS_CORRUPTION    W_ERROR(0x00003703)
+#define WERR_SXS_EARLY_DEACTIVATION    W_ERROR(0x00003704)
+#define WERR_SXS_INVALID_DEACTIVATION  W_ERROR(0x00003705)
+#define WERR_SXS_MULTIPLE_DEACTIVATION W_ERROR(0x00003706)
+#define WERR_SXS_PROCESS_TERMINATION_REQUESTED W_ERROR(0x00003707)
+#define WERR_SXS_RELEASE_ACTIVATION_ONTEXT     W_ERROR(0x00003708)
+#define WERR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY       W_ERROR(0x00003709)
+#define WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE      W_ERROR(0x0000370A)
+#define WERR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME       W_ERROR(0x0000370B)
+#define WERR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE  W_ERROR(0x0000370C)
+#define WERR_SXS_IDENTITY_PARSE_ERROR  W_ERROR(0x0000370D)
+#define WERR_MALFORMED_SUBSTITUTION_STRING     W_ERROR(0x0000370E)
+#define WERR_SXS_INCORRECT_PUBLIC_KEY_OKEN     W_ERROR(0x0000370F)
+#define WERR_UNMAPPED_SUBSTITUTION_STRING      W_ERROR(0x00003710)
+#define WERR_SXS_ASSEMBLY_NOT_LOCKED   W_ERROR(0x00003711)
+#define WERR_SXS_COMPONENT_STORE_CORRUPT       W_ERROR(0x00003712)
+#define WERR_ADVANCED_INSTALLER_FAILED W_ERROR(0x00003713)
+#define WERR_XML_ENCODING_MISMATCH     W_ERROR(0x00003714)
+#define WERR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT W_ERROR(0x00003715)
+#define WERR_SXS_IDENTITIES_DIFFERENT  W_ERROR(0x00003716)
+#define WERR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT  W_ERROR(0x00003717)
+#define WERR_SXS_FILE_NOT_PART_OF_ASSEMBLY     W_ERROR(0x00003718)
+#define WERR_SXS_MANIFEST_TOO_BIG      W_ERROR(0x00003719)
+#define WERR_SXS_SETTING_NOT_REGISTERED        W_ERROR(0x0000371A)
+#define WERR_SXS_TRANSACTION_CLOSURE_INCOMPLETE        W_ERROR(0x0000371B)
+#define WERR_EVT_INVALID_CHANNEL_PATH  W_ERROR(0x00003A98)
+#define WERR_EVT_INVALID_QUERY W_ERROR(0x00003A99)
+#define WERR_EVT_PUBLISHER_METADATA_NOT_FOUND  W_ERROR(0x00003A9A)
+#define WERR_EVT_EVENT_TEMPLATE_NOT_FOUND      W_ERROR(0x00003A9B)
+#define WERR_EVT_INVALID_PUBLISHER_NAME        W_ERROR(0x00003A9C)
+#define WERR_EVT_INVALID_EVENT_DATA    W_ERROR(0x00003A9D)
+#define WERR_EVT_CHANNEL_NOT_FOUND     W_ERROR(0x00003A9F)
+#define WERR_EVT_MALFORMED_XML_TEXT    W_ERROR(0x00003AA0)
+#define WERR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL        W_ERROR(0x00003AA1)
+#define WERR_EVT_CONFIGURATION_ERROR   W_ERROR(0x00003AA2)
+#define WERR_EVT_QUERY_RESULT_STALE    W_ERROR(0x00003AA3)
+#define WERR_EVT_QUERY_RESULT_INVALID_POSITION W_ERROR(0x00003AA4)
+#define WERR_EVT_NON_VALIDATING_MSXML  W_ERROR(0x00003AA5)
+#define WERR_EVT_FILTER_ALREADYSCOPED  W_ERROR(0x00003AA6)
+#define WERR_EVT_FILTER_NOTELTSET      W_ERROR(0x00003AA7)
+#define WERR_EVT_FILTER_INVARG W_ERROR(0x00003AA8)
+#define WERR_EVT_FILTER_INVTEST        W_ERROR(0x00003AA9)
+#define WERR_EVT_FILTER_INVTYPE        W_ERROR(0x00003AAA)
+#define WERR_EVT_FILTER_PARSEERR       W_ERROR(0x00003AAB)
+#define WERR_EVT_FILTER_UNSUPPORTEDOP  W_ERROR(0x00003AAC)
+#define WERR_EVT_FILTER_UNEXPECTEDTOKEN        W_ERROR(0x00003AAD)
+#define WERR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL W_ERROR(0x00003AAE)
+#define WERR_EVT_INVALID_CHANNEL_PROPERTY_VALUE        W_ERROR(0x00003AAF)
+#define WERR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE      W_ERROR(0x00003AB0)
+#define WERR_EVT_CHANNEL_CANNOT_ACTIVATE       W_ERROR(0x00003AB1)
+#define WERR_EVT_FILTER_TOO_COMPLEX    W_ERROR(0x00003AB2)
+#define WERR_EVT_MESSAGE_NOT_FOUND     W_ERROR(0x00003AB3)
+#define WERR_EVT_MESSAGE_ID_NOT_FOUND  W_ERROR(0x00003AB4)
+#define WERR_EVT_UNRESOLVED_VALUE_INSERT       W_ERROR(0x00003AB5)
+#define WERR_EVT_UNRESOLVED_PARAMETER_INSERT   W_ERROR(0x00003AB6)
+#define WERR_EVT_MAX_INSERTS_REACHED   W_ERROR(0x00003AB7)
+#define WERR_EVT_EVENT_DEFINITION_NOT_OUND     W_ERROR(0x00003AB8)
+#define WERR_EVT_MESSAGE_LOCALE_NOT_FOUND      W_ERROR(0x00003AB9)
+#define WERR_EVT_VERSION_TOO_OLD       W_ERROR(0x00003ABA)
+#define WERR_EVT_VERSION_TOO_NEW       W_ERROR(0x00003ABB)
+#define WERR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY  W_ERROR(0x00003ABC)
+#define WERR_EVT_PUBLISHER_DISABLED    W_ERROR(0x00003ABD)
+#define WERR_EC_SUBSCRIPTION_CANNOT_ACTIVATE   W_ERROR(0x00003AE8)
+#define WERR_EC_LOG_DISABLED   W_ERROR(0x00003AE9)
+#define WERR_MUI_FILE_NOT_FOUND        W_ERROR(0x00003AFC)
+#define WERR_MUI_INVALID_FILE  W_ERROR(0x00003AFD)
+#define WERR_MUI_INVALID_RC_CONFIG     W_ERROR(0x00003AFE)
+#define WERR_MUI_INVALID_LOCALE_NAME   W_ERROR(0x00003AFF)
+#define WERR_MUI_INVALID_ULTIMATEFALLBACK_NAME W_ERROR(0x00003B00)
+#define WERR_MUI_FILE_NOT_LOADED       W_ERROR(0x00003B01)
+#define WERR_RESOURCE_ENUM_USER_STOP   W_ERROR(0x00003B02)
+#define WERR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED     W_ERROR(0x00003B03)
+#define WERR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME      W_ERROR(0x00003B04)
+#define WERR_MCA_INVALID_CAPABILITIES_STRING   W_ERROR(0x00003B60)
+#define WERR_MCA_INVALID_VCP_VERSION   W_ERROR(0x00003B61)
+#define WERR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION   W_ERROR(0x00003B62)
+#define WERR_MCA_MCCS_VERSION_MISMATCH W_ERROR(0x00003B63)
+#define WERR_MCA_UNSUPPORTED_MCCS_VERSION      W_ERROR(0x00003B64)
+#define WERR_MCA_INTERNAL_ERROR        W_ERROR(0x00003B65)
+#define WERR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED      W_ERROR(0x00003B66)
+#define WERR_MCA_UNSUPPORTED_COLOR_TEMPERATURE W_ERROR(0x00003B67)
+#define WERR_AMBIGUOUS_SYSTEM_DEVICE   W_ERROR(0x00003B92)
+#define WERR_SYSTEM_DEVICE_NOT_FOUND   W_ERROR(0x00003BC3)
+/* END GENERATED-WIN32-ERROR-CODES */
+
 /*****************************************************************************
  returns a windows error message.  not amazingly helpful, but better than a number.
  *****************************************************************************/

diff --git a/libds/common/flags.h b/libds/common/flags.h
index 37103bcec2e6a08a84da3c25c6a8dc5720e6e9c1..46d037253feb3905c89da1473901a337c9f703f2 100644 (file)
--- a/libds/common/flags.h
+++ b/libds/common/flags.h
@@ -183,3 +183,10 @@
 /* sa->systemFlags on attributes */
 #define DS_FLAG_ATTR_NOT_REPLICATED    0x00000001
 #define DS_FLAG_ATTR_IS_CONSTRUCTED    0x00000004
+
+/* 7.1.1.2.2.1.2.1.1           nTDSDSA Object options flags */
+#define DS_NTDSDSA_OPT_IS_GC                    0x00000001
+#define DS_NTDSDSA_OPT_DISABLE_INBOUND_REPL     0x00000002
+#define DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL    0x00000004
+#define DS_NTDSDSA_OPT_DISABLE_NTDSCONN_XLATE   0x00000008
+#define DS_NTDSDSA_OPT_DISABLE_SPN_REGISTRATION 0x00000010

diff --git a/librpc/gen_ndr/cli_samr.c b/librpc/gen_ndr/cli_samr.c
index 27119e53cc32c7bc79794869badf5637375c3f6e..72f5f74864ae00d2893d849a441cfbdbc20f5508 100644 (file)
--- a/librpc/gen_ndr/cli_samr.c
+++ b/librpc/gen_ndr/cli_samr.c
@@ -10448,7 +10448,7 @@ struct tevent_req *rpccli_samr_ChangePasswordUser3_send(TALLOC_CTX *mem_ctx,
                                                        struct samr_Password *_lm_verifier /* [in] [unique] */,
                                                        struct samr_CryptPassword *_password3 /* [in] [unique] */,
                                                        struct samr_DomInfo1 **_dominfo /* [out] [ref] */,
-                                                       struct samr_ChangeReject **_reject /* [out] [ref] */)
+                                                       struct userPwdChangeFailureInformation **_reject /* [out] [ref] */)
 {
        struct tevent_req *req;
        struct rpccli_samr_ChangePasswordUser3_state *state;
@@ -10576,7 +10576,7 @@ NTSTATUS rpccli_samr_ChangePasswordUser3(struct rpc_pipe_client *cli,
                                         struct samr_Password *lm_verifier /* [in] [unique] */,
                                         struct samr_CryptPassword *password3 /* [in] [unique] */,
                                         struct samr_DomInfo1 **dominfo /* [out] [ref] */,
-                                        struct samr_ChangeReject **reject /* [out] [ref] */)
+                                        struct userPwdChangeFailureInformation **reject /* [out] [ref] */)
 {
        struct samr_ChangePasswordUser3 r;
        NTSTATUS status;

diff --git a/librpc/gen_ndr/cli_samr.h b/librpc/gen_ndr/cli_samr.h
index ed2baa9aba122af40c417286e9a79a81f3c2fa36..c94ff11cc7a8fcc046580e516c74c3f5495a7fb8 100644 (file)
--- a/librpc/gen_ndr/cli_samr.h
+++ b/librpc/gen_ndr/cli_samr.h
@@ -963,7 +963,7 @@ struct tevent_req *rpccli_samr_ChangePasswordUser3_send(TALLOC_CTX *mem_ctx,
                                                        struct samr_Password *_lm_verifier /* [in] [unique] */,
                                                        struct samr_CryptPassword *_password3 /* [in] [unique] */,
                                                        struct samr_DomInfo1 **_dominfo /* [out] [ref] */,
-                                                       struct samr_ChangeReject **_reject /* [out] [ref] */);
+                                                       struct userPwdChangeFailureInformation **_reject /* [out] [ref] */);
 NTSTATUS rpccli_samr_ChangePasswordUser3_recv(struct tevent_req *req,
                                              TALLOC_CTX *mem_ctx,
                                              NTSTATUS *result);
@@ -978,7 +978,7 @@ NTSTATUS rpccli_samr_ChangePasswordUser3(struct rpc_pipe_client *cli,
                                         struct samr_Password *lm_verifier /* [in] [unique] */,
                                         struct samr_CryptPassword *password3 /* [in] [unique] */,
                                         struct samr_DomInfo1 **dominfo /* [out] [ref] */,
-                                        struct samr_ChangeReject **reject /* [out] [ref] */);
+                                        struct userPwdChangeFailureInformation **reject /* [out] [ref] */);
 struct tevent_req *rpccli_samr_Connect5_send(TALLOC_CTX *mem_ctx,
                                             struct tevent_context *ev,
                                             struct rpc_pipe_client *cli,

diff --git a/librpc/gen_ndr/drsuapi.h b/librpc/gen_ndr/drsuapi.h
index 52b6ee9ac2f1b732beb251c755c57e0e6ae1bd69..96b0651c4f426de0f854b37567265c83ac2468b4 100644 (file)
--- a/librpc/gen_ndr/drsuapi.h
+++ b/librpc/gen_ndr/drsuapi.h
@@ -15,6 +15,38 @@
 #define DRSUAPI_DS_BIND_GUID_W2K3      ( "6afab99c-6e26-464a-975f-f58f105218bc" )
 #define DRSUAPI_DS_MEMBERSHIP_FLAG_GROUP_ATTR  ( 0x1 )
 #define DRSUAPI_NTDSDSA_KRB5_SERVICE_GUID      ( "E3514235-4B06-11D1-AB04-00C04FC2DCD2" )
+/* bitmap drsuapi_DrsOptions */
+#define DRSUAPI_DRS_ASYNC_OP ( 0x00000001 )
+#define DRSUAPI_DRS_GETCHG_CHECK ( 0x00000002 )
+#define DRSUAPI_DRS_ADD_REF ( 0x00000004 )
+#define DRSUAPI_DRS_SYNC_ALL ( 0x00000008 )
+#define DRSUAPI_DRS_DEL_REF ( 0x00000008 )
+#define DRSUAPI_DRS_WRIT_REP ( 0x00000010 )
+#define DRSUAPI_DRS_INIT_SYNC ( 0x00000020 )
+#define DRSUAPI_DRS_PER_SYNC ( 0x00000040 )
+#define DRSUAPI_DRS_MAIL_REP ( 0x00000080 )
+#define DRSUAPI_DRS_ASYNC_REP ( 0x00000100 )
+#define DRSUAPI_DRS_IGNORE_ERROR ( 0x00000100 )
+#define DRSUAPI_DRS_TWOWAY_SYNC ( 0x00000200 )
+#define DRSUAPI_DRS_CRITICAL_ONLY ( 0x00000400 )
+#define DRSUAPI_DRS_GET_ANC ( 0x00000800 )
+#define DRSUAPI_DRS_GET_NC_SIZE ( 0x00001000 )
+#define DRSUAPI_DRS_LOCAL_ONLY ( 0x00001000 )
+#define DRSUAPI_DRS_SYNC_BYNAME ( 0x00004000 )
+#define DRSUAPI_DRS_REF_OK ( 0x00004000 )
+#define DRSUAPI_DRS_FULL_SYNC_NOW ( 0x00008000 )
+#define DRSUAPI_DRS_NO_SOURCE ( 0x00008000 )
+#define DRSUAPI_DRS_FULL_SYNC_PACKET ( 0x00020000 )
+#define DRSUAPI_DRS_REF_GCSPN ( 0x00100000 )
+#define DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING ( 0x00800000 )
+#define DRSUAPI_DRS_SYNC_FORCED ( 0x02000000 )
+#define DRSUAPI_DRS_DISABLE_AUTO_SYNC ( 0x04000000 )
+#define DRSUAPI_DRS_DISABLE_PERIODIC_SYNC ( 0x08000000 )
+#define DRSUAPI_DRS_USE_COMPRESSION ( 0x10000000 )
+#define DRSUAPI_DRS_NEVER_NOTIFY ( 0x20000000 )
+#define DRSUAPI_DRS_SYNC_PAS ( 0x40000000 )
+#define DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP ( 0x80000000 )
+
 /* bitmap drsuapi_SupportedExtensions */
 #define DRSUAPI_SUPPORTED_EXTENSION_BASE ( 0x00000001 )
 #define DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION ( 0x00000002 )
@@ -261,9 +293,9 @@ struct drsuapi_DsGetNCChangesRequest5 {
 };
 
 struct drsuapi_DsReplicaOID {
-       uint32_t __ndr_size;/* [value(ndr_size_drsuapi_DsReplicaOID_oid(oid,0)),range(0,10000)] */
-       const char *oid;/* [unique,charset(DOS),size_is(__ndr_size)] */
-}/* [nopush,nopull] */;
+       uint32_t length;/* [range(0,10000)] */
+       uint8_t *binary_oid;/* [unique,size_is(length)] */
+}/* [noprint] */;
 
 struct drsuapi_DsReplicaOIDMapping {
        uint32_t id_prefix;

diff --git a/librpc/gen_ndr/misc.h b/librpc/gen_ndr/misc.h
index aa24a0fe17426a3a0e6296f4c66ba9337cb16f1a..29ea19296af9ec10877ac807c0bec71cdb2219d3 100644 (file)
--- a/librpc/gen_ndr/misc.h
+++ b/librpc/gen_ndr/misc.h
@@ -50,4 +50,45 @@ struct KRB5_EDATA_NTSTATUS {
        uint32_t unknown2;
 }/* [public] */;
 
+enum winreg_Type
+#ifndef USE_UINT_ENUMS
+ {
+       REG_NONE=(int)(0),
+       REG_SZ=(int)(1),
+       REG_EXPAND_SZ=(int)(2),
+       REG_BINARY=(int)(3),
+       REG_DWORD=(int)(4),
+       REG_DWORD_BIG_ENDIAN=(int)(5),
+       REG_LINK=(int)(6),
+       REG_MULTI_SZ=(int)(7),
+       REG_RESOURCE_LIST=(int)(8),
+       REG_FULL_RESOURCE_DESCRIPTOR=(int)(9),
+       REG_RESOURCE_REQUIREMENTS_LIST=(int)(10),
+       REG_QWORD=(int)(11)
+}
+#else
+ { __donnot_use_enum_winreg_Type=0x7FFFFFFF}
+#define REG_NONE ( 0 )
+#define REG_SZ ( 1 )
+#define REG_EXPAND_SZ ( 2 )
+#define REG_BINARY ( 3 )
+#define REG_DWORD ( 4 )
+#define REG_DWORD_BIG_ENDIAN ( 5 )
+#define REG_LINK ( 6 )
+#define REG_MULTI_SZ ( 7 )
+#define REG_RESOURCE_LIST ( 8 )
+#define REG_FULL_RESOURCE_DESCRIPTOR ( 9 )
+#define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
+#define REG_QWORD ( 11 )
+#endif
+;
+
+union winreg_Data {
+       const char * string;/* [flag(LIBNDR_FLAG_STR_NULLTERM),case(REG_SZ)] */
+       DATA_BLOB binary;/* [flag(LIBNDR_FLAG_REMAINING),case(REG_BINARY)] */
+       uint32_t value;/* [case(REG_DWORD)] */
+       const char ** string_array;/* [flag(LIBNDR_FLAG_STR_NULLTERM),case(REG_MULTI_SZ)] */
+       DATA_BLOB data;/* [flag(LIBNDR_FLAG_REMAINING),default] */
+}/* [nodiscriminant,public] */;
+
 #endif /* _HEADER_misc */

diff --git a/librpc/gen_ndr/nbt.h b/librpc/gen_ndr/nbt.h
index ec234e1748f6f4b16a6ba380ec1c52d7dda70d6d..dc39a5c912717afc9708c0fd4cae3ab4066d78c2 100644 (file)
--- a/librpc/gen_ndr/nbt.h
+++ b/librpc/gen_ndr/nbt.h
@@ -411,7 +411,10 @@ struct nbt_sockaddr {
 #define NBT_SERVER_NDNC ( 0x00000400 )
 #define NBT_SERVER_SELECT_SECRET_DOMAIN_6 ( 0x00000800 )
 #define NBT_SERVER_FULL_SECRET_DOMAIN_6 ( 0x00001000 )
-#define NBT_SERVER_DNS_FOREST ( 0x01000000 )
+#define NBT_SERVER_ADS_WEB_SERVICE ( 0x00002000 )
+#define NBT_SERVER_HAS_DNS_NAME ( 0x20000000 )
+#define NBT_SERVER_IS_DEFAULT_NC ( 0x40000000 )
+#define NBT_SERVER_FOREST_ROOT ( 0x80000000 )
 
 /* bitmap netlogon_nt_version_flags */
 #define NETLOGON_NT_VERSION_1 ( 0x00000001 )

diff --git a/librpc/gen_ndr/ndr_dcerpc.c b/librpc/gen_ndr/ndr_dcerpc.c
index c86984109fb78c5bf6204de7b6826887d090f907..37f6d548183ebd30cc3b8bc727a3489f75dadfe5 100644 (file)
--- a/librpc/gen_ndr/ndr_dcerpc.c
+++ b/librpc/gen_ndr/ndr_dcerpc.c
@@ -15,6 +15,7 @@ static enum ndr_err_code ndr_push_dcerpc_ctx_list(struct ndr_push *ndr, int ndr_
                for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < r->num_transfer_syntaxes; cntr_transfer_syntaxes_0++) {
                        NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -37,6 +38,7 @@ static enum ndr_err_code ndr_pull_dcerpc_ctx_list(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transfer_syntaxes_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -88,6 +90,7 @@ static enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, int ndr_flag
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -123,6 +126,7 @@ static enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, int ndr_flag
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -157,6 +161,7 @@ static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -167,6 +172,7 @@ static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -184,6 +190,7 @@ static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, int ndr_fl
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        default: {
                                NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
@@ -214,6 +221,7 @@ static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, int ndr_fl
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        default: {
                                NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
@@ -276,6 +284,7 @@ static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, int ndr_f
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -303,6 +312,7 @@ static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -330,6 +340,7 @@ static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->result));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reason));
                NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -343,6 +354,7 @@ static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->result));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reason));
                NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -385,6 +397,7 @@ static enum ndr_err_code ndr_push_dcerpc_bind_ack(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -422,6 +435,7 @@ static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -463,6 +477,7 @@ static enum ndr_err_code ndr_push_dcerpc_bind_nak_versions(struct ndr_push *ndr,
                for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->versions[cntr_versions_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -483,6 +498,7 @@ static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions(struct ndr_pull *ndr,
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_versions_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -512,6 +528,7 @@ static enum ndr_err_code ndr_push_dcerpc_bind_nak_versions_ctr(struct ndr_push *
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
                                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
@@ -541,6 +558,7 @@ static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions_ctr(struct ndr_pull *
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
@@ -587,6 +605,7 @@ static enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reject_reason));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->versions, r->reject_reason));
                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
@@ -601,6 +620,7 @@ static enum ndr_err_code ndr_pull_dcerpc_bind_nak(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reject_reason));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->versions, r->reject_reason));
                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
@@ -637,6 +657,7 @@ static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -662,6 +683,7 @@ static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -694,6 +716,7 @@ static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, int ndr_fla
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -714,6 +737,7 @@ static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, int ndr_fla
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -809,6 +833,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, int ndr_fl
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -830,6 +855,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, int ndr_fl
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -860,6 +886,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, int ndr_f
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -877,6 +904,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -903,6 +931,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, int nd
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -920,6 +949,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, int nd
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -946,6 +976,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -963,6 +994,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -984,6 +1016,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -996,6 +1029,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1018,6 +1052,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1031,6 +1066,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1062,6 +1098,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, int ndr_fl
                for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1088,6 +1125,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, int ndr_fl
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1123,6 +1161,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1133,6 +1172,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1150,6 +1190,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, int ndr_fl
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1160,6 +1201,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, int ndr_fl
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1177,6 +1219,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, int nd
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1187,6 +1230,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, int nd
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1204,6 +1248,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, int ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1214,6 +1259,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, int ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1274,6 +1320,7 @@ static enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, int ndr_f
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case DCERPC_PKT_REQUEST: {
                                NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
@@ -1435,6 +1482,7 @@ static enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, int ndr_f
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case DCERPC_PKT_REQUEST: {
                                NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
@@ -1695,6 +1743,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ncacn_packet(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
@@ -1716,6 +1765,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ncacn_packet(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
@@ -1765,6 +1815,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
@@ -1797,6 +1848,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));

diff --git a/librpc/gen_ndr/ndr_dfs.c b/librpc/gen_ndr/ndr_dfs.c
index 20d3f22004d2b4823da6b94724edaa45f7e152e5..62f42bad155500396b6b6ef970a7c3774459b539 100644 (file)
--- a/librpc/gen_ndr/ndr_dfs.c
+++ b/librpc/gen_ndr/ndr_dfs.c
@@ -35,6 +35,7 @@ static enum ndr_err_code ndr_push_dfs_Info0(struct ndr_push *ndr, int ndr_flags,
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -45,6 +46,7 @@ static enum ndr_err_code ndr_pull_dfs_Info0(struct ndr_pull *ndr, int ndr_flags,
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -63,6 +65,7 @@ static enum ndr_err_code ndr_push_dfs_Info1(struct ndr_push *ndr, int ndr_flags,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -87,6 +90,7 @@ static enum ndr_err_code ndr_pull_dfs_Info1(struct ndr_pull *ndr, int ndr_flags,
                } else {
                        r->path = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -153,6 +157,7 @@ static enum ndr_err_code ndr_push_dfs_Info2(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
                NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -193,6 +198,7 @@ static enum ndr_err_code ndr_pull_dfs_Info2(struct ndr_pull *ndr, int ndr_flags,
                }
                NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_stores));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -275,6 +281,7 @@ static enum ndr_err_code ndr_push_dfs_StorageInfo(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_dfs_StorageState(ndr, NDR_SCALARS, r->state));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->share));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server) {
@@ -314,6 +321,7 @@ static enum ndr_err_code ndr_pull_dfs_StorageInfo(struct ndr_pull *ndr, int ndr_
                } else {
                        r->share = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server) {
@@ -374,6 +382,7 @@ static enum ndr_err_code ndr_push_dfs_Info3(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->stores));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -433,6 +442,7 @@ static enum ndr_err_code ndr_pull_dfs_Info3(struct ndr_pull *ndr, int ndr_flags,
                } else {
                        r->stores = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -531,6 +541,7 @@ static enum ndr_err_code ndr_push_dfs_Info4(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->stores));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -592,6 +603,7 @@ static enum ndr_err_code ndr_pull_dfs_Info4(struct ndr_pull *ndr, int ndr_flags,
                } else {
                        r->stores = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -718,6 +730,7 @@ static enum ndr_err_code ndr_push_dfs_Info5(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_dfs_PropertyFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pktsize));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -762,6 +775,7 @@ static enum ndr_err_code ndr_pull_dfs_Info5(struct ndr_pull *ndr, int ndr_flags,
                NDR_CHECK(ndr_pull_dfs_PropertyFlags(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pktsize));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_stores));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -853,6 +867,7 @@ static enum ndr_err_code ndr_push_dfs_Target_Priority(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_dfs_Target_PriorityClass(ndr, NDR_SCALARS, r->target_priority_class));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->target_priority_rank));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -866,6 +881,7 @@ static enum ndr_err_code ndr_pull_dfs_Target_Priority(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_dfs_Target_PriorityClass(ndr, NDR_SCALARS, &r->target_priority_class));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->target_priority_rank));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -888,6 +904,7 @@ static enum ndr_err_code ndr_push_dfs_StorageInfo2(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_dfs_Target_Priority(ndr, NDR_SCALARS, &r->target_priority));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->info));
@@ -901,6 +918,7 @@ static enum ndr_err_code ndr_pull_dfs_StorageInfo2(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_dfs_Target_Priority(ndr, NDR_SCALARS, &r->target_priority));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->info));
@@ -931,6 +949,7 @@ static enum ndr_err_code ndr_push_dfs_Info6(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pktsize));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_stores));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->stores));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entry_path) {
@@ -994,6 +1013,7 @@ static enum ndr_err_code ndr_pull_dfs_Info6(struct ndr_pull *ndr, int ndr_flags,
                } else {
                        r->stores = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entry_path) {
@@ -1089,6 +1109,7 @@ static enum ndr_err_code ndr_push_dfs_Info7(struct ndr_push *ndr, int ndr_flags,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->generation_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1100,6 +1121,7 @@ static enum ndr_err_code ndr_pull_dfs_Info7(struct ndr_pull *ndr, int ndr_flags,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->generation_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1119,6 +1141,7 @@ static enum ndr_err_code ndr_push_dfs_Info100(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -1143,6 +1166,7 @@ static enum ndr_err_code ndr_pull_dfs_Info100(struct ndr_pull *ndr, int ndr_flag
                } else {
                        r->comment = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -1179,6 +1203,7 @@ static enum ndr_err_code ndr_push_dfs_Info101(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_dfs_StorageState(ndr, NDR_SCALARS, r->state));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1190,6 +1215,7 @@ static enum ndr_err_code ndr_pull_dfs_Info101(struct ndr_pull *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_dfs_StorageState(ndr, NDR_SCALARS, &r->state));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1209,6 +1235,7 @@ static enum ndr_err_code ndr_push_dfs_Info102(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1220,6 +1247,7 @@ static enum ndr_err_code ndr_pull_dfs_Info102(struct ndr_pull *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1239,6 +1267,7 @@ static enum ndr_err_code ndr_push_dfs_Info103(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_dfs_PropertyFlags(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1250,6 +1279,7 @@ static enum ndr_err_code ndr_pull_dfs_Info103(struct ndr_pull *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_dfs_PropertyFlags(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1269,6 +1299,7 @@ static enum ndr_err_code ndr_push_dfs_Info104(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1280,6 +1311,7 @@ static enum ndr_err_code ndr_pull_dfs_Info104(struct ndr_pull *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1303,6 +1335,7 @@ static enum ndr_err_code ndr_push_dfs_Info105(struct ndr_push *ndr, int ndr_flag
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->property_flag_mask));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->property_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -1331,6 +1364,7 @@ static enum ndr_err_code ndr_pull_dfs_Info105(struct ndr_pull *ndr, int ndr_flag
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->property_flag_mask));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->property_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -1372,6 +1406,7 @@ static enum ndr_err_code ndr_push_dfs_Info106(struct ndr_push *ndr, int ndr_flag
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_dfs_StorageState(ndr, NDR_SCALARS, r->state));
                NDR_CHECK(ndr_push_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1384,6 +1419,7 @@ static enum ndr_err_code ndr_pull_dfs_Info106(struct ndr_pull *ndr, int ndr_flag
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_dfs_StorageState(ndr, NDR_SCALARS, &r->state));
                NDR_CHECK(ndr_pull_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1404,6 +1440,7 @@ static enum ndr_err_code ndr_push_dfs_Info200(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dom_root));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dom_root) {
@@ -1428,6 +1465,7 @@ static enum ndr_err_code ndr_pull_dfs_Info200(struct ndr_pull *ndr, int ndr_flag
                } else {
                        r->dom_root = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dom_root) {
@@ -1461,14 +1499,14 @@ _PUBLIC_ void ndr_print_dfs_Info200(struct ndr_print *ndr, const char *name, con
 
 static enum ndr_err_code ndr_push_dfs_VolumeFlavor(struct ndr_push *ndr, int ndr_flags, enum dfs_VolumeFlavor r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_dfs_VolumeFlavor(struct ndr_pull *ndr, int ndr_flags, enum dfs_VolumeFlavor *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -1490,6 +1528,7 @@ static enum ndr_err_code ndr_push_dfs_Info300(struct ndr_push *ndr, int ndr_flag
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_dfs_VolumeFlavor(ndr, NDR_SCALARS, r->flavor));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dom_root));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dom_root) {
@@ -1515,6 +1554,7 @@ static enum ndr_err_code ndr_pull_dfs_Info300(struct ndr_pull *ndr, int ndr_flag
                } else {
                        r->dom_root = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dom_root) {
@@ -1552,6 +1592,7 @@ static enum ndr_err_code ndr_push_dfs_Info(struct ndr_push *ndr, int ndr_flags,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -1742,6 +1783,7 @@ static enum ndr_err_code ndr_pull_dfs_Info(struct ndr_pull *ndr, int ndr_flags,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -2194,6 +2236,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray1(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2224,6 +2267,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray1(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2280,6 +2324,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray2(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2310,6 +2355,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray2(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2366,6 +2412,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray3(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2396,6 +2443,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray3(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2452,6 +2500,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray4(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2482,6 +2531,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray4(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2538,6 +2588,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray5(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2568,6 +2619,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray5(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2624,6 +2676,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray6(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2654,6 +2707,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray6(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2710,6 +2764,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray200(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2740,6 +2795,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray200(struct ndr_pull *ndr, int ndr
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2796,6 +2852,7 @@ static enum ndr_err_code ndr_push_dfs_EnumArray300(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2826,6 +2883,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumArray300(struct ndr_pull *ndr, int ndr
                } else {
                        r->s = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->s) {
@@ -2880,6 +2938,7 @@ static enum ndr_err_code ndr_push_dfs_EnumInfo(struct ndr_push *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
@@ -2993,6 +3052,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumInfo(struct ndr_pull *ndr, int ndr_fla
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_info1;
@@ -3249,6 +3309,7 @@ static enum ndr_err_code ndr_push_dfs_EnumStruct(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->e, r->level));
                NDR_CHECK(ndr_push_dfs_EnumInfo(ndr, NDR_SCALARS, &r->e));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dfs_EnumInfo(ndr, NDR_BUFFERS, &r->e));
@@ -3263,6 +3324,7 @@ static enum ndr_err_code ndr_pull_dfs_EnumStruct(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->e, r->level));
                NDR_CHECK(ndr_pull_dfs_EnumInfo(ndr, NDR_SCALARS, &r->e));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dfs_EnumInfo(ndr, NDR_BUFFERS, &r->e));
@@ -3286,6 +3348,7 @@ static enum ndr_err_code ndr_push_dfs_UnknownStruct(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->unknown2) {
@@ -3311,6 +3374,7 @@ static enum ndr_err_code ndr_pull_dfs_UnknownStruct(struct ndr_pull *ndr, int nd
                } else {
                        r->unknown2 = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->unknown2) {

diff --git a/librpc/gen_ndr/ndr_drsblobs.c b/librpc/gen_ndr/ndr_drsblobs.c
index 5b57b361ea09d03418ec06220d535cfa40e218b8..8a0842bce3ed5cdfddc9d977e9a4b3cf94bb5694 100644 (file)
--- a/librpc/gen_ndr/ndr_drsblobs.c
+++ b/librpc/gen_ndr/ndr_drsblobs.c
@@ -17,6 +17,7 @@ static enum ndr_err_code ndr_push_replPropertyMetaData1(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -33,6 +34,7 @@ static enum ndr_err_code ndr_pull_replPropertyMetaData1(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -62,6 +64,7 @@ static enum ndr_err_code ndr_push_replPropertyMetaDataCtr1(struct ndr_push *ndr,
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -83,6 +86,7 @@ static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr1(struct ndr_pull *ndr,
                        NDR_CHECK(ndr_pull_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -113,6 +117,7 @@ static enum ndr_err_code ndr_push_replPropertyMetaDataCtr(struct ndr_push *ndr,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -140,6 +145,7 @@ static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr(struct ndr_pull *ndr,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -184,6 +190,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_replPropertyMetaDataBlob(struct ndr_push *nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_push_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -198,6 +205,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_replPropertyMetaDataBlob(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_pull_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -225,6 +233,7 @@ static enum ndr_err_code ndr_push_replUpToDateVectorCtr1(struct ndr_push *ndr, i
                for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -246,6 +255,7 @@ static enum ndr_err_code ndr_pull_replUpToDateVectorCtr1(struct ndr_pull *ndr, i
                        NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -282,6 +292,7 @@ static enum ndr_err_code ndr_push_replUpToDateVectorCtr2(struct ndr_push *ndr, i
                for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -303,6 +314,7 @@ static enum ndr_err_code ndr_pull_replUpToDateVectorCtr2(struct ndr_pull *ndr, i
                        NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -333,6 +345,7 @@ static enum ndr_err_code ndr_push_replUpToDateVectorCtr(struct ndr_push *ndr, in
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -367,6 +380,7 @@ static enum ndr_err_code ndr_pull_replUpToDateVectorCtr(struct ndr_pull *ndr, in
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -422,6 +436,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_replUpToDateVectorBlob(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_push_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -436,6 +451,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_replUpToDateVectorBlob(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_pull_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -459,6 +475,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1OtherInfo(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->dns_name) + 1));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, strlen(r->dns_name) + 1, sizeof(uint8_t), CH_DOS));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -471,6 +488,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1OtherInfo(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__dns_name_size));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, r->__dns_name_size, sizeof(uint8_t), CH_DOS));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -512,6 +530,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1(struct ndr_push *ndr, int ndr_fl
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 8));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->other_info) {
@@ -553,6 +572,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1(struct ndr_pull *ndr, int ndr_fl
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->other_info) {
@@ -629,6 +649,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo2OtherInfo(struct ndr_push *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
@@ -692,6 +713,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo2OtherInfo(struct ndr_pull *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
@@ -779,6 +801,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo2(struct ndr_push *ndr, int ndr_fl
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
                        NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 8));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->other_info) {
@@ -821,6 +844,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo2(struct ndr_pull *ndr, int ndr_fl
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
                        NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->other_info) {
@@ -881,6 +905,7 @@ static enum ndr_err_code ndr_push_repsFromTo(struct ndr_push *ndr, int ndr_flags
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
@@ -917,6 +942,7 @@ static enum ndr_err_code ndr_pull_repsFromTo(struct ndr_pull *ndr, int ndr_flags
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
@@ -974,6 +1000,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_repsFromToBlob(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
@@ -989,6 +1016,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_repsFromToBlob(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
@@ -1016,6 +1044,7 @@ static enum ndr_err_code ndr_push_partialAttributeSetCtr1(struct ndr_push *ndr,
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1036,6 +1065,7 @@ static enum ndr_err_code ndr_pull_partialAttributeSetCtr1(struct ndr_pull *ndr,
                        NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1065,6 +1095,7 @@ static enum ndr_err_code ndr_push_partialAttributeSetCtr(struct ndr_push *ndr, i
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -1092,6 +1123,7 @@ static enum ndr_err_code ndr_pull_partialAttributeSetCtr(struct ndr_pull *ndr, i
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -1136,6 +1168,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_partialAttributeSetBlob(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_push_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1150,6 +1183,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_partialAttributeSetBlob(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_pull_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1195,6 +1229,7 @@ static enum ndr_err_code ndr_push_prefixMapCtr(struct ndr_push *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case PREFIX_MAP_VERSION_DSDB: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
@@ -1223,6 +1258,7 @@ static enum ndr_err_code ndr_pull_prefixMapCtr(struct ndr_pull *ndr, int ndr_fla
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case PREFIX_MAP_VERSION_DSDB: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
@@ -1268,6 +1304,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_prefixMapBlob(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -1283,6 +1320,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_prefixMapBlob(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -1305,6 +1343,7 @@ static enum ndr_err_code ndr_push_ldapControlDirSyncExtra(struct ndr_push *ndr,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 0: {
                        break; }
@@ -1334,6 +1373,7 @@ static enum ndr_err_code ndr_pull_ldapControlDirSyncExtra(struct ndr_pull *ndr,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 0: {
                        break; }
@@ -1391,6 +1431,7 @@ static enum ndr_err_code ndr_push_ldapControlDirSyncBlob(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->extra, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, ndr->iconv_convenience, 0)));
                NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
@@ -1411,6 +1452,7 @@ static enum ndr_err_code ndr_pull_ldapControlDirSyncBlob(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->extra, r->extra_length));
                NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
@@ -1447,6 +1489,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ldapControlDirSyncCookie(struct ndr_push *nd
                        NDR_CHECK(ndr_push_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
@@ -1468,6 +1511,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ldapControlDirSyncCookie(struct ndr_pull *nd
                        NDR_CHECK(ndr_pull_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
@@ -1494,6 +1538,7 @@ static enum ndr_err_code ndr_push_supplementalCredentialsPackage(struct ndr_push
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 2 * strlen_m(r->name), sizeof(uint8_t), CH_UTF16));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data, strlen(r->data), sizeof(uint8_t), CH_DOS));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1509,6 +1554,7 @@ static enum ndr_err_code ndr_pull_supplementalCredentialsPackage(struct ndr_pull
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, r->name_len, sizeof(uint8_t), CH_UTF16));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data, r->data_len, sizeof(uint8_t), CH_DOS));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1532,7 +1578,7 @@ static enum ndr_err_code ndr_push_supplementalCredentialsSignature(struct ndr_pu
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+               NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
                ndr->flags = _flags_save_ENUM;
        }
        return NDR_ERR_SUCCESS;
@@ -1544,7 +1590,7 @@ static enum ndr_err_code ndr_pull_supplementalCredentialsSignature(struct ndr_pu
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+               NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
                *r = v;
                ndr->flags = _flags_save_ENUM;
        }
@@ -1570,13 +1616,14 @@ static enum ndr_err_code ndr_push_supplementalCredentialsSubBlob(struct ndr_push
 {
        uint32_t cntr_packages_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 2));
+               NDR_CHECK(ndr_push_align(ndr, 3));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_PREFIX, 0x30, sizeof(uint16_t), CH_UTF16));
                NDR_CHECK(ndr_push_supplementalCredentialsSignature(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_SIGNATURE));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_packages));
                for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
                        NDR_CHECK(ndr_push_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 3));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1588,7 +1635,7 @@ static enum ndr_err_code ndr_pull_supplementalCredentialsSubBlob(struct ndr_pull
        uint32_t cntr_packages_0;
        TALLOC_CTX *_mem_save_packages_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 2));
+               NDR_CHECK(ndr_pull_align(ndr, 3));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->prefix, 0x30, sizeof(uint16_t), CH_UTF16));
                NDR_CHECK(ndr_pull_supplementalCredentialsSignature(ndr, NDR_SCALARS, &r->signature));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_packages));
@@ -1599,6 +1646,7 @@ static enum ndr_err_code ndr_pull_supplementalCredentialsSubBlob(struct ndr_pull
                        NDR_CHECK(ndr_pull_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_packages_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1645,6 +1693,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_supplementalCredentialsBlob(struct ndr_push
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
                }
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1665,6 +1714,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_supplementalCredentialsBlob(struct ndr_pull
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sub, 0, r->__ndr_size));
                }
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown3));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1693,6 +1743,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_package_PackagesBlob(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->names));
                        ndr->flags = _flags_save_string_array;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1709,6 +1760,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_package_PackagesBlob(struct ndr_pull *ndr, i
                        NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->names));
                        ndr->flags = _flags_save_string_array;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1735,6 +1787,7 @@ static enum ndr_err_code ndr_push_package_PrimaryKerberosString(struct ndr_push
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->string));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1775,6 +1828,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryKerberosString(struct ndr_pull
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1831,6 +1885,7 @@ static enum ndr_err_code ndr_push_package_PrimaryKerberosKey3(struct ndr_push *n
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1874,6 +1929,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey3(struct ndr_pull *n
                        }
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1938,6 +1994,7 @@ static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr3(struct ndr_push *n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
@@ -1981,6 +2038,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr3(struct ndr_pull *n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding5));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
@@ -2053,6 +2111,7 @@ static enum ndr_err_code ndr_push_package_PrimaryKerberosKey4(struct ndr_push *n
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2097,6 +2156,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey4(struct ndr_pull *n
                        }
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2164,6 +2224,7 @@ static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr4(struct ndr_push *n
                for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
                        NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
@@ -2226,6 +2287,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr4(struct ndr_pull *n
                        NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
@@ -2318,6 +2380,7 @@ static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr(struct ndr_push *nd
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 3: {
                                NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
@@ -2354,6 +2417,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr(struct ndr_pull *nd
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 3: {
                                NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
@@ -2411,6 +2475,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryKerberosBlob(struct ndr_push
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -2426,6 +2491,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryKerberosBlob(struct ndr_pull
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
                NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -2454,6 +2520,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryCLEARTEXTBlob(struct ndr_push
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->cleartext));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2470,6 +2537,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryCLEARTEXTBlob(struct ndr_pull
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->cleartext));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2492,6 +2560,7 @@ static enum ndr_err_code ndr_push_package_PrimaryWDigestHash(struct ndr_push *nd
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2508,6 +2577,7 @@ static enum ndr_err_code ndr_pull_package_PrimaryWDigestHash(struct ndr_pull *nd
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2542,6 +2612,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryWDigestBlob(struct ndr_push *
                for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
                        NDR_CHECK(ndr_push_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2566,6 +2637,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryWDigestBlob(struct ndr_pull *
                        NDR_CHECK(ndr_pull_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hashes_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2600,6 +2672,7 @@ static enum ndr_err_code ndr_push_AuthInfoNone(struct ndr_push *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2611,6 +2684,7 @@ static enum ndr_err_code ndr_pull_AuthInfoNone(struct ndr_pull *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2631,6 +2705,7 @@ static enum ndr_err_code ndr_push_AuthInfoNT4Owf(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 16));
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->password));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2643,6 +2718,7 @@ static enum ndr_err_code ndr_pull_AuthInfoNT4Owf(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->password));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2664,6 +2740,7 @@ static enum ndr_err_code ndr_push_AuthInfoClear(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2677,6 +2754,7 @@ static enum ndr_err_code ndr_pull_AuthInfoClear(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
                NDR_PULL_ALLOC_N(ndr, r->password, r->size);
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2698,6 +2776,7 @@ static enum ndr_err_code ndr_push_AuthInfoVersion(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2710,6 +2789,7 @@ static enum ndr_err_code ndr_pull_AuthInfoVersion(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2729,6 +2809,7 @@ static enum ndr_err_code ndr_push_AuthInfo(struct ndr_push *ndr, int ndr_flags,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case TRUST_AUTH_TYPE_NONE: {
                                NDR_CHECK(ndr_push_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
@@ -2777,6 +2858,7 @@ static enum ndr_err_code ndr_pull_AuthInfo(struct ndr_pull *ndr, int ndr_flags,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case TRUST_AUTH_TYPE_NONE: {
                                NDR_CHECK(ndr_pull_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
@@ -2860,6 +2942,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_AuthenticationInformation(struct ndr_push *n
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2880,6 +2963,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_AuthenticationInformation(struct ndr_pull *n
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2912,6 +2996,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_trustCurrentPasswords(struct ndr_push *ndr,
                for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->current[cntr_current_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
@@ -2946,6 +3031,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_trustCurrentPasswords(struct ndr_pull *ndr,
                        }
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_current_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -3015,6 +3101,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_trustDomainPasswords(struct ndr_push *ndr, i
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3039,6 +3126,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_DsCompressedChunk(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->marker));
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3051,6 +3139,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_DsCompressedChunk(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->marker));
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3072,6 +3161,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorAString(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -3095,6 +3185,7 @@ static enum ndr_err_code ndr_pull_ExtendedErrorAString(struct ndr_pull *ndr, int
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -3131,6 +3222,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorUString(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -3154,6 +3246,7 @@ static enum ndr_err_code ndr_pull_ExtendedErrorUString(struct ndr_pull *ndr, int
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -3190,6 +3283,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorBlob(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -3213,6 +3307,7 @@ static enum ndr_err_code ndr_pull_ExtendedErrorBlob(struct ndr_pull *ndr, int nd
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -3246,14 +3341,14 @@ _PUBLIC_ void ndr_print_ExtendedErrorBlob(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_ExtendedErrorComputerNamePresent(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_ExtendedErrorComputerNamePresent(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -3274,6 +3369,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorComputerNameU(struct ndr_push *nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
                                NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
@@ -3309,10 +3405,11 @@ static enum ndr_err_code ndr_pull_ExtendedErrorComputerNameU(struct ndr_pull *nd
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
                                NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
@@ -3366,6 +3463,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorComputerName(struct ndr_push *ndr
                NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, r->present));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->n, r->present));
                NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
@@ -3380,6 +3478,7 @@ static enum ndr_err_code ndr_pull_ExtendedErrorComputerName(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, &r->present));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->n, r->present));
                NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
@@ -3399,14 +3498,14 @@ _PUBLIC_ void ndr_print_ExtendedErrorComputerName(struct ndr_print *ndr, const c
 
 static enum ndr_err_code ndr_push_ExtendedErrorParamType(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorParamType r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_ExtendedErrorParamType(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorParamType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -3432,6 +3531,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorParamU(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
                                NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
@@ -3504,10 +3604,11 @@ static enum ndr_err_code ndr_pull_ExtendedErrorParamU(struct ndr_pull *ndr, int
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
                                NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
@@ -3618,6 +3719,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorParam(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->p, r->type));
                NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
@@ -3632,6 +3734,7 @@ static enum ndr_err_code ndr_pull_ExtendedErrorParam(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_ExtendedErrorParamType(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->p, r->type));
                NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
@@ -3667,6 +3770,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ExtendedErrorInfo(struct ndr_push *ndr, int
                for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
                        NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next) {
@@ -3713,6 +3817,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ExtendedErrorInfo(struct ndr_pull *ndr, int
                if (r->params) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->params, r->num_params));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next) {
@@ -3769,6 +3874,7 @@ static enum ndr_err_code ndr_push_ExtendedErrorInfoPtr(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -3790,6 +3896,7 @@ static enum ndr_err_code ndr_pull_ExtendedErrorInfoPtr(struct ndr_pull *ndr, int
                } else {
                        r->info = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {

diff --git a/librpc/gen_ndr/ndr_drsuapi.c b/librpc/gen_ndr/ndr_drsuapi.c
index a09566c600a4d757eb3aa8000f6da52f1bea1875..f09affcfb53d9361f419243c41674ddbbd99cd96 100644 (file)
--- a/librpc/gen_ndr/ndr_drsuapi.c
+++ b/librpc/gen_ndr/ndr_drsuapi.c
@@ -7,6 +7,57 @@
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "librpc/gen_ndr/ndr_samr.h"
 #include "librpc/ndr/ndr_compression.h"
+_PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DrsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+{
+       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DrsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DrsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
+{
+       ndr_print_uint32(ndr, name, r);
+       ndr->depth++;
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_OP", DRSUAPI_DRS_ASYNC_OP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GETCHG_CHECK", DRSUAPI_DRS_GETCHG_CHECK, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ADD_REF", DRSUAPI_DRS_ADD_REF, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_ALL", DRSUAPI_DRS_SYNC_ALL, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DEL_REF", DRSUAPI_DRS_DEL_REF, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_WRIT_REP", DRSUAPI_DRS_WRIT_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC", DRSUAPI_DRS_INIT_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PER_SYNC", DRSUAPI_DRS_PER_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_MAIL_REP", DRSUAPI_DRS_MAIL_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_REP", DRSUAPI_DRS_ASYNC_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_IGNORE_ERROR", DRSUAPI_DRS_IGNORE_ERROR, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_TWOWAY_SYNC", DRSUAPI_DRS_TWOWAY_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_CRITICAL_ONLY", DRSUAPI_DRS_CRITICAL_ONLY, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ANC", DRSUAPI_DRS_GET_ANC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_NC_SIZE", DRSUAPI_DRS_GET_NC_SIZE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_LOCAL_ONLY", DRSUAPI_DRS_LOCAL_ONLY, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
+       ndr->depth--;
+}
+
 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -92,6 +143,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -105,6 +157,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -129,6 +182,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -143,6 +197,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -170,6 +225,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
                NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -186,6 +242,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
                NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -215,6 +272,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *nd
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -231,6 +289,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *nd
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -249,6 +308,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int n
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 1));
                switch (level) {
                        case 24: {
                                {
@@ -313,6 +373,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 1));
                switch (level) {
                        case 24: {
                                {
@@ -403,6 +464,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
                NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -419,6 +481,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, in
                }
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
                NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -446,6 +509,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -467,6 +531,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr
                if (r->dn) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -550,6 +615,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -594,6 +660,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -643,6 +710,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -676,6 +744,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -720,6 +789,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_pu
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -733,6 +803,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pu
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -755,6 +826,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -767,6 +839,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -795,6 +868,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *
                for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -825,6 +899,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *
                if (r->cursors) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1011,6 +1086,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
                NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -1049,6 +1125,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
                NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -1090,18 +1167,55 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, co
        ndr->depth--;
 }
 
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
 {
-       ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
-       ndr->depth++;
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
-       ndr_print_ptr(ndr, "oid", r->oid);
-       ndr->depth++;
-       if (r->oid) {
-               ndr_print_string(ndr, "oid", r->oid);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
-       ndr->depth--;
-       ndr->depth--;
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->binary_oid) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
+                       NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
+{
+       uint32_t _ptr_binary_oid;
+       TALLOC_CTX *_mem_save_binary_oid_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
+               if (r->length > 10000) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
+               if (_ptr_binary_oid) {
+                       NDR_PULL_ALLOC(ndr, r->binary_oid);
+               } else {
+                       r->binary_oid = NULL;
+               }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->binary_oid) {
+                       _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
+                       NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
+                       NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
+               }
+               if (r->binary_oid) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
+               }
+       }
+       return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
@@ -1110,6 +1224,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
@@ -1123,6 +1238,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *n
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
@@ -1146,6 +1262,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_p
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->mappings) {
@@ -1179,6 +1296,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_p
                } else {
                        r->mappings = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->mappings) {
@@ -1347,6 +1465,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push
                for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1376,6 +1495,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull
                if (r->attids) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1423,6 +1543,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -1485,6 +1606,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull
                        r->partial_attribute_set_ex = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -1573,6 +1695,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_pus
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -1636,6 +1759,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pul
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -1709,6 +1833,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 5: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
@@ -1758,6 +1883,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 5: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
@@ -1826,6 +1952,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *nd
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1839,6 +1966,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1868,6 +1996,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push
                for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1898,6 +2027,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull
                if (r->cursors) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1932,6 +2062,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->blob) {
@@ -1957,6 +2088,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr,
                } else {
                        r->blob = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->blob) {
@@ -1990,6 +2122,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->values) {
@@ -2023,6 +2156,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *n
                } else {
                        r->values = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->values) {
@@ -2082,6 +2216,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct nd
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -2099,6 +2234,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct nd
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -2141,6 +2277,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(str
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -2165,6 +2302,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(str
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -2198,6 +2336,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
                NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
@@ -2211,6 +2350,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
@@ -2234,6 +2374,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attributes) {
@@ -2267,6 +2408,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull
                } else {
                        r->attributes = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attributes) {
@@ -2347,6 +2489,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2371,6 +2514,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2407,6 +2551,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr
                NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2421,6 +2566,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2448,6 +2594,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push
                for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2475,6 +2622,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull
                if (r->meta_data) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2509,6 +2657,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -2555,6 +2704,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr
                } else {
                        r->meta_data_ctr = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -2596,6 +2746,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2649,6 +2800,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *
                        r->first_object = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2745,6 +2897,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_
                NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2772,6 +2925,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_
                NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2825,6 +2979,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2904,6 +3059,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *
                        r->linked_attributes = NULL;
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -3017,6 +3173,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push
                        NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3033,6 +3190,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull
                        NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3057,6 +3215,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push
                        NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3073,6 +3232,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull
                        NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3101,6 +3261,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pul
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3152,6 +3313,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pul
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3203,6 +3365,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pu
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3254,6 +3417,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pu
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3323,6 +3487,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
                        int level = ndr_push_get_switch_value(ndr, r);
+                       NDR_CHECK(ndr_push_union_align(ndr, 5));
                        switch (level) {
                                case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
                                        NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
@@ -3380,6 +3545,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                level = ndr_pull_get_switch_value(ndr, r);
                if (ndr_flags & NDR_SCALARS) {
+                       NDR_CHECK(ndr_pull_union_align(ndr, 5));
                        switch (level) {
                                case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
                                        NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
@@ -3465,6 +3631,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
@@ -3477,6 +3644,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
@@ -3500,6 +3668,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *nd
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3521,6 +3690,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *nd
                }
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3544,6 +3714,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -3601,6 +3772,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -3714,6 +3886,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr
                NDR_CHECK(ndr_push_ref_ptr(ndr));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -3746,6 +3919,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -3785,6 +3959,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -3818,6 +3993,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -3889,6 +4065,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -3924,6 +4101,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -3978,6 +4156,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -4035,6 +4214,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -4105,6 +4285,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -4146,6 +4327,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -4228,6 +4410,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *
                NDR_CHECK(ndr_push_ref_ptr(ndr));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -4262,6 +4445,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *
                        r->source_dsa_address = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -4307,6 +4491,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -4340,6 +4525,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -4414,6 +4600,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -4452,6 +4639,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -4501,6 +4689,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -4534,6 +4723,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -4614,6 +4804,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
@@ -4693,6 +4884,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
@@ -4846,6 +5038,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -4879,6 +5072,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -4926,6 +5120,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_pu
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
@@ -4975,6 +5170,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pu
                } else {
                        r->domain = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
@@ -5058,6 +5254,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -5091,6 +5288,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pul
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -5136,6 +5334,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_p
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -5164,6 +5363,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_p
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -5202,6 +5402,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -5235,6 +5436,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pu
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -5287,6 +5489,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data1) {
@@ -5336,6 +5539,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull
                } else {
                        r->data2 = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data1) {
@@ -5397,6 +5601,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -5430,6 +5635,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -5565,6 +5771,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str) {
@@ -5589,6 +5796,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int
                } else {
                        r->str = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str) {
@@ -5632,6 +5840,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -5670,6 +5879,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, i
                } else {
                        r->names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -5729,6 +5939,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -5762,6 +5973,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -5806,6 +6018,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dns_domain_name) {
@@ -5845,6 +6058,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int
                } else {
                        r->result_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dns_domain_name) {
@@ -5902,6 +6116,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5932,6 +6147,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5986,6 +6202,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
@@ -6022,6 +6239,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_ctr1;
@@ -6111,6 +6329,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_p
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -6160,6 +6379,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_p
                } else {
                        r->spn_names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -6234,6 +6454,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -6267,6 +6488,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pu
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -6309,6 +6531,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -6320,6 +6543,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -6339,6 +6563,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
@@ -6371,6 +6596,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pul
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
@@ -6414,6 +6640,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_pu
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_dn) {
@@ -6453,6 +6680,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pu
                        r->domain_dn = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_dn) {
@@ -6508,6 +6736,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -6541,6 +6770,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pul
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -6583,6 +6813,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -6594,6 +6825,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -6613,6 +6845,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
@@ -6645,6 +6878,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
@@ -6687,6 +6921,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain_name) {
@@ -6712,6 +6947,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *n
                        r->domain_name = NULL;
                }
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain_name) {
@@ -6749,6 +6985,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -6782,6 +7019,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -6830,6 +7068,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -6912,6 +7151,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -7024,6 +7264,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7057,6 +7298,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7124,6 +7366,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -7239,6 +7482,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -7392,6 +7636,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7425,6 +7670,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7493,6 +7739,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -7609,6 +7856,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -7763,6 +8011,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7796,6 +8045,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7861,6 +8111,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_account) {
@@ -7896,6 +8147,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *n
                } else {
                        r->client_account = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_account) {
@@ -7940,6 +8192,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7973,6 +8226,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -8027,6 +8281,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DC_INFO_CTR_1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -8084,6 +8339,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, i
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DC_INFO_CTR_1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -8163,6 +8419,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_p
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -8186,6 +8443,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_p
                        r->next_object = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -8204,6 +8462,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
@@ -8216,6 +8475,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
@@ -8236,6 +8496,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
@@ -8269,6 +8530,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
@@ -8314,6 +8576,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8328,6 +8591,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8351,6 +8615,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -8377,6 +8642,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -8416,6 +8682,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push
                NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
@@ -8431,6 +8698,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
@@ -8455,6 +8723,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_pu
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next) {
@@ -8478,6 +8747,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pu
                        r->next = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next) {
@@ -8512,6 +8782,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -8536,6 +8807,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -8569,6 +8841,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
@@ -8630,6 +8903,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
@@ -8718,6 +8992,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -8742,6 +9017,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr,
                } else {
                        r->info = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -8776,6 +9052,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
@@ -8809,6 +9086,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
@@ -8852,6 +9130,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -8865,6 +9144,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -8891,6 +9171,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -8937,6 +9218,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, i
                } else {
                        r->objects = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -9010,6 +9292,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -9067,6 +9350,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, i
                } else {
                        r->objects = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -9148,6 +9432,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
@@ -9189,6 +9474,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
@@ -9267,6 +9553,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
                NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9279,6 +9566,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
                NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9299,6 +9587,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
@@ -9331,6 +9620,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
@@ -9437,6 +9727,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pu
                NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -9463,6 +9754,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pu
                        r->object_dn = NULL;
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -9507,6 +9799,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pu
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -9563,6 +9856,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pu
                        r->string2 = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -9639,6 +9933,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_GET_INFO: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -9680,6 +9975,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pul
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_GET_INFO: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -9749,6 +10045,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *nd
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context_dn) {
@@ -9827,6 +10124,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context_dn) {
@@ -9935,6 +10233,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -9963,6 +10262,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10006,6 +10306,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *nd
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10031,6 +10332,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *nd
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10067,6 +10369,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -10096,6 +10399,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -10143,6 +10447,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pus
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10171,6 +10476,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pul
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10212,6 +10518,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dsa_obj_dn) {
@@ -10240,6 +10547,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dsa_obj_dn) {
@@ -10286,6 +10594,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10314,6 +10623,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10348,14 +10658,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr
 
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -10379,6 +10689,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
@@ -10438,10 +10749,11 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
@@ -10542,6 +10854,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->nc_dn) {
@@ -10602,6 +10915,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->nc_dn) {
@@ -10688,6 +11002,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, i
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10716,6 +11031,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, i
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10763,6 +11079,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_pu
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -10820,6 +11137,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pu
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -10900,6 +11218,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10928,6 +11247,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10971,6 +11291,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *n
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10996,6 +11317,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *n
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11030,6 +11352,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->source_dsa_obj_dn) {
@@ -11057,6 +11380,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr,
                } else {
                        r->source_dsa_obj_dn = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->source_dsa_obj_dn) {
@@ -11102,6 +11426,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *n
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -11130,6 +11455,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *n
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -11173,6 +11499,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -11216,6 +11543,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull
                } else {
                        r->originating_dsa_dn = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -11281,6 +11609,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pu
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -11309,6 +11638,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pu
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -11357,6 +11687,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_p
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -11428,6 +11759,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_p
                } else {
                        r->originating_dsa_dn = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -11526,6 +11858,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct nd
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -11554,6 +11887,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct nd
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -11602,6 +11936,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push
                        ndr->flags = _flags_save_ipv4address;
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11624,6 +11959,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull
                        ndr->flags = _flags_save_ipv4address;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11655,6 +11991,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_pu
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11683,6 +12020,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pu
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11721,6 +12059,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str1) {
@@ -11752,6 +12091,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str1) {
@@ -11801,6 +12141,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, i
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -11832,6 +12173,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, i
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -11869,6 +12211,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
@@ -12059,6 +12402,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
                                uint32_t _ptr_neighbours;
@@ -12509,6 +12853,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -12542,6 +12887,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -12586,6 +12932,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_p
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->req_array) {
@@ -12622,6 +12969,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_p
                } else {
                        r->req_array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->req_array) {
@@ -12691,6 +13039,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
@@ -12724,6 +13073,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pu
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
@@ -12767,6 +13117,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -12779,6 +13130,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -12802,6 +13154,7 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -12833,6 +13186,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *
                        r->info = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -12885,6 +13239,7 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -12918,6 +13273,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -12964,6 +13320,7 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_pu
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->site_from) {
@@ -13018,6 +13375,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pu
                        r->site_to = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->site_from) {
@@ -13112,6 +13470,7 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -13145,6 +13504,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pul
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));

diff --git a/librpc/gen_ndr/ndr_drsuapi.h b/librpc/gen_ndr/ndr_drsuapi.h
index f157cc5c1f0984388fb00c939e2e8b59018bd45c..bf82ab805f1942a38e2e15b7eab750156fb15335 100644 (file)
--- a/librpc/gen_ndr/ndr_drsuapi.h
+++ b/librpc/gen_ndr/ndr_drsuapi.h
@@ -63,6 +63,9 @@ extern const struct ndr_interface_table ndr_table_drsuapi;
 #define NDR_DRSUAPI_QUERYSITESBYCOST (0x18)
 
 #define NDR_DRSUAPI_CALL_COUNT (25)
+enum ndr_err_code ndr_push_drsuapi_DrsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r);
+enum ndr_err_code ndr_pull_drsuapi_DrsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r);
+void ndr_print_drsuapi_DrsOptions(struct ndr_print *ndr, const char *name, uint32_t r);
 void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r);
 void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r);
 void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r);
@@ -93,8 +96,6 @@ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char
 void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r);
 void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r);
 void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r);
-enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r);
-enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r);
 void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r);
 void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r);
 enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r);

diff --git a/librpc/gen_ndr/ndr_dssetup.c b/librpc/gen_ndr/ndr_dssetup.c
index 995bae54a3997d980389341457c5e4faa231b7f4..27b839bd0732386c005fe7b231d36066f95b64d3 100644 (file)
--- a/librpc/gen_ndr/ndr_dssetup.c
+++ b/librpc/gen_ndr/ndr_dssetup.c
@@ -6,14 +6,14 @@
 #include "librpc/gen_ndr/ndr_misc.h"
 static enum ndr_err_code ndr_push_dssetup_DsRole(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRole r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_dssetup_DsRole(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRole *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -68,6 +68,7 @@ static enum ndr_err_code ndr_push_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_p
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->forest));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain) {
@@ -123,6 +124,7 @@ static enum ndr_err_code ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_p
                        r->forest = NULL;
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain) {
@@ -220,14 +222,14 @@ _PUBLIC_ void ndr_print_dssetup_DsUpgrade(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_dssetup_DsPrevious(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsPrevious r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_dssetup_DsPrevious(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsPrevious *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -250,6 +252,7 @@ static enum ndr_err_code ndr_push_dssetup_DsRoleUpgradeStatus(struct ndr_push *n
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_dssetup_DsUpgrade(ndr, NDR_SCALARS, r->upgrading));
                NDR_CHECK(ndr_push_dssetup_DsPrevious(ndr, NDR_SCALARS, r->previous_role));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -262,6 +265,7 @@ static enum ndr_err_code ndr_pull_dssetup_DsRoleUpgradeStatus(struct ndr_pull *n
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_dssetup_DsUpgrade(ndr, NDR_SCALARS, &r->upgrading));
                NDR_CHECK(ndr_pull_dssetup_DsPrevious(ndr, NDR_SCALARS, &r->previous_role));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -279,14 +283,14 @@ _PUBLIC_ void ndr_print_dssetup_DsRoleUpgradeStatus(struct ndr_print *ndr, const
 
 static enum ndr_err_code ndr_push_dssetup_DsRoleOp(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRoleOp r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_dssetup_DsRoleOp(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRoleOp *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -306,8 +310,9 @@ _PUBLIC_ void ndr_print_dssetup_DsRoleOp(struct ndr_print *ndr, const char *name
 static enum ndr_err_code ndr_push_dssetup_DsRoleOpStatus(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRoleOpStatus *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 2));
+               NDR_CHECK(ndr_push_align(ndr, 3));
                NDR_CHECK(ndr_push_dssetup_DsRoleOp(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 3));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -317,8 +322,9 @@ static enum ndr_err_code ndr_push_dssetup_DsRoleOpStatus(struct ndr_push *ndr, i
 static enum ndr_err_code ndr_pull_dssetup_DsRoleOpStatus(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRoleOpStatus *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 2));
+               NDR_CHECK(ndr_pull_align(ndr, 3));
                NDR_CHECK(ndr_pull_dssetup_DsRoleOp(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -335,14 +341,14 @@ _PUBLIC_ void ndr_print_dssetup_DsRoleOpStatus(struct ndr_print *ndr, const char
 
 static enum ndr_err_code ndr_push_dssetup_DsRoleInfoLevel(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRoleInfoLevel r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_dssetup_DsRoleInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRoleInfoLevel *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -364,6 +370,7 @@ static enum ndr_err_code ndr_push_dssetup_DsRoleInfo(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DS_ROLE_BASIC_INFORMATION: {
                                NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
@@ -407,10 +414,11 @@ static enum ndr_err_code ndr_pull_dssetup_DsRoleInfo(struct ndr_pull *ndr, int n
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DS_ROLE_BASIC_INFORMATION: {
                                NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));

diff --git a/librpc/gen_ndr/ndr_echo.c b/librpc/gen_ndr/ndr_echo.c
index 1f56c80b68579491f2979e06016b1477161a7c7c..4c54ff47c30008ad9ba129c63411936a649ab592 100644 (file)
--- a/librpc/gen_ndr/ndr_echo.c
+++ b/librpc/gen_ndr/ndr_echo.c
@@ -8,6 +8,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_echo_info1(struct ndr_push *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19,6 +20,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_echo_info1(struct ndr_pull *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -38,6 +40,7 @@ static enum ndr_err_code ndr_push_echo_info2(struct ndr_push *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->v));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -49,6 +52,7 @@ static enum ndr_err_code ndr_pull_echo_info2(struct ndr_pull *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->v));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -68,6 +72,7 @@ static enum ndr_err_code ndr_push_echo_info3(struct ndr_push *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->v));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -79,6 +84,7 @@ static enum ndr_err_code ndr_pull_echo_info3(struct ndr_pull *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->v));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -98,6 +104,7 @@ static enum ndr_err_code ndr_push_STRUCT_echo_info4(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->v));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -109,6 +116,7 @@ static enum ndr_err_code ndr_pull_STRUCT_echo_info4(struct ndr_pull *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->v));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -129,6 +137,7 @@ static enum ndr_err_code ndr_push_echo_info5(struct ndr_push *ndr, int ndr_flags
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v1));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->v2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -141,6 +150,7 @@ static enum ndr_err_code ndr_pull_echo_info5(struct ndr_pull *ndr, int ndr_flags
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v1));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->v2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -162,6 +172,7 @@ static enum ndr_err_code ndr_push_echo_info6(struct ndr_push *ndr, int ndr_flags
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v1));
                NDR_CHECK(ndr_push_echo_info1(ndr, NDR_SCALARS, &r->info1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -174,6 +185,7 @@ static enum ndr_err_code ndr_pull_echo_info6(struct ndr_pull *ndr, int ndr_flags
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v1));
                NDR_CHECK(ndr_pull_echo_info1(ndr, NDR_SCALARS, &r->info1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -195,6 +207,7 @@ static enum ndr_err_code ndr_push_echo_info7(struct ndr_push *ndr, int ndr_flags
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v1));
                NDR_CHECK(ndr_push_STRUCT_echo_info4(ndr, NDR_SCALARS, &r->info4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -207,6 +220,7 @@ static enum ndr_err_code ndr_pull_echo_info7(struct ndr_pull *ndr, int ndr_flags
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v1));
                NDR_CHECK(ndr_pull_STRUCT_echo_info4(ndr, NDR_SCALARS, &r->info4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -227,6 +241,7 @@ static enum ndr_err_code ndr_push_echo_Info(struct ndr_push *ndr, int ndr_flags,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_echo_info1(ndr, NDR_SCALARS, &r->info1));
@@ -301,6 +316,7 @@ static enum ndr_err_code ndr_pull_echo_Info(struct ndr_pull *ndr, int ndr_flags,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_echo_info1(ndr, NDR_SCALARS, &r->info1));
@@ -405,14 +421,14 @@ _PUBLIC_ void ndr_print_echo_Info(struct ndr_print *ndr, const char *name, const
 
 static enum ndr_err_code ndr_push_echo_Enum1(struct ndr_push *ndr, int ndr_flags, enum echo_Enum1 r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_echo_Enum1(struct ndr_pull *ndr, int ndr_flags, enum echo_Enum1 *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -459,6 +475,7 @@ static enum ndr_err_code ndr_push_echo_Enum2(struct ndr_push *ndr, int ndr_flags
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, r->e1));
                NDR_CHECK(ndr_push_echo_Enum1_32(ndr, NDR_SCALARS, r->e2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -471,6 +488,7 @@ static enum ndr_err_code ndr_pull_echo_Enum2(struct ndr_pull *ndr, int ndr_flags
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, &r->e1));
                NDR_CHECK(ndr_pull_echo_Enum1_32(ndr, NDR_SCALARS, &r->e2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -491,6 +509,7 @@ static enum ndr_err_code ndr_push_echo_Enum3(struct ndr_push *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case ECHO_ENUM1: {
                                NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, r->e1));
@@ -530,6 +549,7 @@ static enum ndr_err_code ndr_pull_echo_Enum3(struct ndr_pull *ndr, int ndr_flags
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case ECHO_ENUM1: {
                                NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, &r->e1));
@@ -587,6 +607,7 @@ static enum ndr_err_code ndr_push_echo_Surrounding(struct ndr_push *ndr, int ndr
                for (cntr_surrounding_0 = 0; cntr_surrounding_0 < r->x; cntr_surrounding_0++) {
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->surrounding[cntr_surrounding_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -611,6 +632,7 @@ static enum ndr_err_code ndr_pull_echo_Surrounding(struct ndr_pull *ndr, int ndr
                if (r->surrounding) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->surrounding, r->x));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }

diff --git a/librpc/gen_ndr/ndr_epmapper.c b/librpc/gen_ndr/ndr_epmapper.c
index 917669c1d65ac9af54912313bb49504b2561d9f1..5c3abe774c29275bb3c05cd3542004216935c46c 100644 (file)
--- a/librpc/gen_ndr/ndr_epmapper.c
+++ b/librpc/gen_ndr/ndr_epmapper.c
@@ -57,6 +57,7 @@ static enum ndr_err_code ndr_push_epm_rhs_dnet_nsp(struct ndr_push *ndr, int ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -67,6 +68,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_dnet_nsp(struct ndr_pull *ndr, int ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -84,6 +86,7 @@ static enum ndr_err_code ndr_push_epm_rhs_osi_tp4(struct ndr_push *ndr, int ndr_
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -94,6 +97,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_osi_tp4(struct ndr_pull *ndr, int ndr_
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -111,6 +115,7 @@ static enum ndr_err_code ndr_push_epm_rhs_osi_clns(struct ndr_push *ndr, int ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -121,6 +126,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_osi_clns(struct ndr_pull *ndr, int ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -139,6 +145,7 @@ static enum ndr_err_code ndr_push_epm_rhs_udp(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -150,6 +157,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_udp(struct ndr_pull *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -169,6 +177,7 @@ static enum ndr_err_code ndr_push_epm_rhs_tcp(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -180,6 +189,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_tcp(struct ndr_pull *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -199,6 +209,7 @@ static enum ndr_err_code ndr_push_epm_rhs_ip(struct ndr_push *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipaddr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -210,6 +221,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_ip(struct ndr_pull *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipaddr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -229,6 +241,7 @@ static enum ndr_err_code ndr_push_epm_rhs_ncadg(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -240,6 +253,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_ncadg(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -259,6 +273,7 @@ static enum ndr_err_code ndr_push_epm_rhs_ncacn(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -270,6 +285,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_ncacn(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -294,6 +310,7 @@ static enum ndr_err_code ndr_push_epm_rhs_uuid(struct ndr_push *ndr, int ndr_fla
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -310,6 +327,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_uuid(struct ndr_pull *ndr, int ndr_fla
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -328,6 +346,7 @@ static enum ndr_err_code ndr_push_epm_rhs_ipx(struct ndr_push *ndr, int ndr_flag
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -338,6 +357,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_ipx(struct ndr_pull *ndr, int ndr_flag
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -361,6 +381,7 @@ static enum ndr_err_code ndr_push_epm_rhs_smb(struct ndr_push *ndr, int ndr_flag
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unc));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -377,6 +398,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_smb(struct ndr_pull *ndr, int ndr_flag
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unc));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -401,6 +423,7 @@ static enum ndr_err_code ndr_push_epm_rhs_named_pipe(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -417,6 +440,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_named_pipe(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -441,6 +465,7 @@ static enum ndr_err_code ndr_push_epm_rhs_netbios(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -457,6 +482,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_netbios(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -475,6 +501,7 @@ static enum ndr_err_code ndr_push_epm_rhs_netbeui(struct ndr_push *ndr, int ndr_
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -485,6 +512,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_netbeui(struct ndr_pull *ndr, int ndr_
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -502,6 +530,7 @@ static enum ndr_err_code ndr_push_epm_rhs_spx(struct ndr_push *ndr, int ndr_flag
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -512,6 +541,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_spx(struct ndr_pull *ndr, int ndr_flag
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -529,6 +559,7 @@ static enum ndr_err_code ndr_push_epm_rhs_nb_ipx(struct ndr_push *ndr, int ndr_f
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -539,6 +570,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_nb_ipx(struct ndr_pull *ndr, int ndr_f
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -557,6 +589,7 @@ static enum ndr_err_code ndr_push_epm_rhs_http(struct ndr_push *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -568,6 +601,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_http(struct ndr_pull *ndr, int ndr_fla
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -592,6 +626,7 @@ static enum ndr_err_code ndr_push_epm_rhs_unix_ds(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -608,6 +643,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_unix_ds(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -626,6 +662,7 @@ static enum ndr_err_code ndr_push_epm_rhs_null(struct ndr_push *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -636,6 +673,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_null(struct ndr_pull *ndr, int ndr_fla
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -654,6 +692,7 @@ static enum ndr_err_code ndr_push_epm_rhs_ncalrpc(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -665,6 +704,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_ncalrpc(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -683,6 +723,7 @@ static enum ndr_err_code ndr_push_epm_rhs_appletalk(struct ndr_push *ndr, int nd
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -693,6 +734,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_appletalk(struct ndr_pull *ndr, int nd
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -710,6 +752,7 @@ static enum ndr_err_code ndr_push_epm_rhs_atalk_stream(struct ndr_push *ndr, int
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -720,6 +763,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_atalk_stream(struct ndr_pull *ndr, int
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -737,6 +781,7 @@ static enum ndr_err_code ndr_push_epm_rhs_atalk_datagram(struct ndr_push *ndr, i
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -747,6 +792,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_atalk_datagram(struct ndr_pull *ndr, i
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -765,6 +811,7 @@ static enum ndr_err_code ndr_push_epm_rhs_vines_spp(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -776,6 +823,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_vines_spp(struct ndr_pull *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -795,6 +843,7 @@ static enum ndr_err_code ndr_push_epm_rhs_vines_ipc(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -806,6 +855,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_vines_ipc(struct ndr_pull *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -830,6 +880,7 @@ static enum ndr_err_code ndr_push_epm_rhs_streettalk(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->streettalk));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -846,6 +897,7 @@ static enum ndr_err_code ndr_pull_epm_rhs_streettalk(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->streettalk));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -867,6 +919,7 @@ static enum ndr_err_code ndr_push_epm_rhs(struct ndr_push *ndr, int ndr_flags, c
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
                if (ndr_flags & NDR_SCALARS) {
                        int level = ndr_push_get_switch_value(ndr, r);
+                       NDR_CHECK(ndr_push_union_align(ndr, 4));
                        switch (level) {
                                case EPM_PROTOCOL_DNET_NSP: {
                                        NDR_CHECK(ndr_push_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
@@ -1082,6 +1135,7 @@ static enum ndr_err_code ndr_pull_epm_rhs(struct ndr_pull *ndr, int ndr_flags, u
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
                level = ndr_pull_get_switch_value(ndr, r);
                if (ndr_flags & NDR_SCALARS) {
+                       NDR_CHECK(ndr_pull_union_align(ndr, 4));
                        switch (level) {
                                case EPM_PROTOCOL_DNET_NSP: {
                                        NDR_CHECK(ndr_pull_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
@@ -1421,6 +1475,7 @@ static enum ndr_err_code ndr_push_epm_lhs(struct ndr_push *ndr, int ndr_flags, c
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->lhs_data));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1438,6 +1493,7 @@ static enum ndr_err_code ndr_pull_epm_lhs(struct ndr_pull *ndr, int ndr_flags, s
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->lhs_data));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1470,6 +1526,7 @@ static enum ndr_err_code ndr_push_epm_floor(struct ndr_push *ndr, int ndr_flags,
                        NDR_CHECK(ndr_push_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_rhs, 2, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1493,6 +1550,7 @@ static enum ndr_err_code ndr_pull_epm_floor(struct ndr_pull *ndr, int ndr_flags,
                        NDR_CHECK(ndr_pull_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_rhs, 2, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1521,6 +1579,7 @@ static enum ndr_err_code ndr_push_epm_tower(struct ndr_push *ndr, int ndr_flags,
                        for (cntr_floors_0 = 0; cntr_floors_0 < r->num_floors; cntr_floors_0++) {
                                NDR_CHECK(ndr_push_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
                        }
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 2));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1546,6 +1605,7 @@ static enum ndr_err_code ndr_pull_epm_tower(struct ndr_pull *ndr, int ndr_flags,
                                NDR_CHECK(ndr_pull_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
                        }
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_floors_0, 0);
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1595,6 +1655,7 @@ static enum ndr_err_code ndr_push_epm_twr_t(struct ndr_push *ndr, int ndr_flags,
                        NDR_CHECK(ndr_push_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_tower, 4, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1612,6 +1673,7 @@ static enum ndr_err_code ndr_pull_epm_twr_t(struct ndr_pull *ndr, int ndr_flags,
                        NDR_CHECK(ndr_pull_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_tower, 4, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1636,6 +1698,7 @@ static enum ndr_err_code ndr_push_epm_entry_t(struct ndr_push *ndr, int ndr_flag
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->annotation) + 1));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->annotation, strlen(r->annotation) + 1, sizeof(uint8_t), CH_DOS));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->tower) {
@@ -1661,6 +1724,7 @@ static enum ndr_err_code ndr_pull_epm_entry_t(struct ndr_pull *ndr, int ndr_flag
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__annotation_offset));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__annotation_length));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->annotation, r->__annotation_length, sizeof(uint8_t), CH_DOS));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->tower) {
@@ -1697,6 +1761,7 @@ static enum ndr_err_code ndr_push_rpc_if_id_t(struct ndr_push *ndr, int ndr_flag
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_major));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_minor));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1710,6 +1775,7 @@ static enum ndr_err_code ndr_pull_rpc_if_id_t(struct ndr_pull *ndr, int ndr_flag
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_major));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_minor));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1731,6 +1797,7 @@ static enum ndr_err_code ndr_push_epm_twr_p_t(struct ndr_push *ndr, int ndr_flag
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_full_ptr(ndr, r->twr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->twr) {
@@ -1752,6 +1819,7 @@ static enum ndr_err_code ndr_pull_epm_twr_p_t(struct ndr_pull *ndr, int ndr_flag
                } else {
                        r->twr = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->twr) {

diff --git a/librpc/gen_ndr/ndr_eventlog.c b/librpc/gen_ndr/ndr_eventlog.c
index 7710999a785c67c393fb5f4d14a2d9c16b146dc3..a7e502c105bd7cb59fc4c881acc599ce0e1d4191 100644 (file)
--- a/librpc/gen_ndr/ndr_eventlog.c
+++ b/librpc/gen_ndr/ndr_eventlog.c
@@ -32,14 +32,14 @@ _PUBLIC_ void ndr_print_eventlogReadFlags(struct ndr_print *ndr, const char *nam
 
 _PUBLIC_ enum ndr_err_code ndr_push_eventlogEventTypes(struct ndr_push *ndr, int ndr_flags, enum eventlogEventTypes r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 _PUBLIC_ enum ndr_err_code ndr_pull_eventlogEventTypes(struct ndr_pull *ndr, int ndr_flags, enum eventlogEventTypes *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -65,6 +65,7 @@ static enum ndr_err_code ndr_push_eventlog_OpenUnknown0(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown0));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -77,6 +78,7 @@ static enum ndr_err_code ndr_pull_eventlog_OpenUnknown0(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown0));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -143,6 +145,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_eventlog_Record_tdb(struct ndr_push *ndr, in
                        }
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->padding));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -210,6 +213,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_eventlog_Record_tdb(struct ndr_pull *ndr, in
                        }
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -309,6 +313,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGHEADER(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, r->Flags));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Retention));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -331,6 +336,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGHEADER(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, &r->Flags));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Retention));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndHeaderSize));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -421,6 +427,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGRECORD(struct ndr_push *ndr, int ndr
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -503,6 +510,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGRECORD(struct ndr_pull *ndr, int ndr
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -573,6 +581,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGEOF(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -593,6 +602,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGEOF(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeEnd));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -626,6 +636,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_EVT_FILE(struct ndr_push *ndr, int
                        NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
                }
                NDR_CHECK(ndr_push_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
@@ -650,6 +661,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_EVT_FILE(struct ndr_pull *ndr, int
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
                NDR_CHECK(ndr_pull_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -687,6 +699,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_FULL_INFORMATION(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->full));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -698,6 +711,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_FULL_INFORMATION(struct ndr_pull *n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->full));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }

diff --git a/librpc/gen_ndr/ndr_krb5pac.c b/librpc/gen_ndr/ndr_krb5pac.c
index 416875261d5db3b3699432457c73ea2e851fe641..0f4cfefe28056433d868f360a31f4371b84b164d 100644 (file)
--- a/librpc/gen_ndr/ndr_krb5pac.c
+++ b/librpc/gen_ndr/ndr_krb5pac.c
@@ -13,6 +13,7 @@ static enum ndr_err_code ndr_push_PAC_LOGON_NAME(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->logon_time));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->account_name)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, 2 * strlen_m(r->account_name), sizeof(uint8_t), CH_UTF16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -26,6 +27,7 @@ static enum ndr_err_code ndr_pull_PAC_LOGON_NAME(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->logon_time));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, r->size, sizeof(uint8_t), CH_UTF16));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -56,6 +58,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_SIGNATURE_DATA(struct ndr_push *ndr, int
                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->signature));
                                ndr->flags = _flags_save_DATA_BLOB;
                        }
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -78,6 +81,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_SIGNATURE_DATA(struct ndr_pull *ndr, int
                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->signature));
                                ndr->flags = _flags_save_DATA_BLOB;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -107,6 +111,7 @@ static enum ndr_err_code ndr_push_PAC_LOGON_INFO(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->res_group_dom_sid));
                NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->res_groups));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
@@ -132,6 +137,7 @@ static enum ndr_err_code ndr_pull_PAC_LOGON_INFO(struct ndr_pull *ndr, int ndr_f
                        r->res_group_dom_sid = NULL;
                }
                NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->res_groups));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
@@ -166,6 +172,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_LOGON_INFO_CTR(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -187,6 +194,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_LOGON_INFO_CTR(struct ndr_pull *ndr, int
                } else {
                        r->info = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -251,6 +259,7 @@ static enum ndr_err_code ndr_push_DATA_BLOB_REM(struct ndr_push *ndr, int ndr_fl
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -267,6 +276,7 @@ static enum ndr_err_code ndr_pull_DATA_BLOB_REM(struct ndr_pull *ndr, int ndr_fl
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -285,6 +295,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_INFO(struct ndr_push *ndr, int ndr_flags
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case PAC_TYPE_LOGON_INFO: {
                                {
@@ -346,6 +357,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_INFO(struct ndr_pull *ndr, int ndr_flags
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case PAC_TYPE_LOGON_INFO: {
                                {
@@ -445,6 +457,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA(struct ndr_push *ndr, int ndr_flags
                for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
                        NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
@@ -469,6 +482,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA(struct ndr_pull *ndr, int ndr_flags
                        NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -514,6 +528,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_BUFFER_RAW(struct ndr_push *ndr, int ndr
                        ndr->flags = _flags_save_DATA_BLOB_REM;
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -555,6 +570,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_BUFFER_RAW(struct ndr_pull *ndr, int ndr
                        ndr->flags = _flags_save_DATA_BLOB_REM;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -607,6 +623,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA_RAW(struct ndr_push *ndr, int ndr_f
                for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
                        NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
@@ -631,6 +648,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA_RAW(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -677,6 +695,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_PAC_Validate(struct ndr_push *ndr, int ndr_f
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->ChecksumAndSignature));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -697,6 +716,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_PAC_Validate(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->ChecksumAndSignature));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -721,6 +741,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netsamlogoncache_entry(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
                NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
@@ -734,6 +755,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netsamlogoncache_entry(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
                NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));

diff --git a/librpc/gen_ndr/ndr_lsa.c b/librpc/gen_ndr/ndr_lsa.c
index b43cfca83118fe83d0e8fa05ce6764eea958c735..ad7b2be32e70ee323c380e30e865622f07b13bbc 100644 (file)
--- a/librpc/gen_ndr/ndr_lsa.c
+++ b/librpc/gen_ndr/ndr_lsa.c
@@ -12,6 +12,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_String(struct ndr_push *ndr, int ndr_fla
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -38,6 +39,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_String(struct ndr_pull *ndr, int ndr_fla
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -83,6 +85,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_StringLarge(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m_term(r->string)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -109,6 +112,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_StringLarge(struct ndr_pull *ndr, int nd
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -154,6 +158,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_Strings(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -184,6 +189,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_Strings(struct ndr_pull *ndr, int ndr_fl
                } else {
                        r->names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -240,6 +246,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiString(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -266,6 +273,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiString(struct ndr_pull *ndr, int nd
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -311,6 +319,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiStringLarge(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->string)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -337,6 +346,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiStringLarge(struct ndr_pull *ndr, i
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -383,6 +393,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_BinaryString(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -413,6 +424,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_BinaryString(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -473,6 +485,7 @@ static enum ndr_err_code ndr_push_lsa_LUID(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->low));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -485,6 +498,7 @@ static enum ndr_err_code ndr_pull_lsa_LUID(struct ndr_pull *ndr, int ndr_flags,
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->low));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -506,6 +520,7 @@ static enum ndr_err_code ndr_push_lsa_PrivEntry(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
@@ -519,6 +534,7 @@ static enum ndr_err_code ndr_pull_lsa_PrivEntry(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
@@ -542,6 +558,7 @@ static enum ndr_err_code ndr_push_lsa_PrivArray(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->privs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->privs) {
@@ -572,6 +589,7 @@ static enum ndr_err_code ndr_pull_lsa_PrivArray(struct ndr_pull *ndr, int ndr_fl
                } else {
                        r->privs = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->privs) {
@@ -624,11 +642,12 @@ _PUBLIC_ void ndr_print_lsa_PrivArray(struct ndr_print *ndr, const char *name, c
 static enum ndr_err_code ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_QosInfo *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->len));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->impersonation_level));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->context_mode));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->effective_only));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -638,11 +657,12 @@ static enum ndr_err_code ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flag
 static enum ndr_err_code ndr_pull_lsa_QosInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_QosInfo *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->len));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->impersonation_level));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->context_mode));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->effective_only));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -653,7 +673,7 @@ _PUBLIC_ void ndr_print_lsa_QosInfo(struct ndr_print *ndr, const char *name, con
 {
        ndr_print_struct(ndr, name, "lsa_QosInfo");
        ndr->depth++;
-       ndr_print_uint32(ndr, "len", r->len);
+       ndr_print_uint3264(ndr, "len", r->len);
        ndr_print_uint16(ndr, "impersonation_level", r->impersonation_level);
        ndr_print_uint8(ndr, "context_mode", r->context_mode);
        ndr_print_uint8(ndr, "effective_only", r->effective_only);
@@ -664,12 +684,13 @@ static enum ndr_err_code ndr_push_lsa_ObjectAttribute(struct ndr_push *ndr, int
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->len));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->root_dir));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_desc));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_qos));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->root_dir) {
@@ -703,7 +724,7 @@ static enum ndr_err_code ndr_pull_lsa_ObjectAttribute(struct ndr_pull *ndr, int
        TALLOC_CTX *_mem_save_sec_qos_0;
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
+               NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->len));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_root_dir));
                if (_ptr_root_dir) {
                        NDR_PULL_ALLOC(ndr, r->root_dir);
@@ -729,6 +750,7 @@ static enum ndr_err_code ndr_pull_lsa_ObjectAttribute(struct ndr_pull *ndr, int
                } else {
                        r->sec_qos = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->root_dir) {
@@ -769,7 +791,7 @@ _PUBLIC_ void ndr_print_lsa_ObjectAttribute(struct ndr_print *ndr, const char *n
 {
        ndr_print_struct(ndr, name, "lsa_ObjectAttribute");
        ndr->depth++;
-       ndr_print_uint32(ndr, "len", r->len);
+       ndr_print_uint3264(ndr, "len", r->len);
        ndr_print_ptr(ndr, "root_dir", r->root_dir);
        ndr->depth++;
        if (r->root_dir) {
@@ -918,6 +940,7 @@ static enum ndr_err_code ndr_push_lsa_AuditLogInfo(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_in_progress));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->time_to_shutdown));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_audit_record));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -934,6 +957,7 @@ static enum ndr_err_code ndr_pull_lsa_AuditLogInfo(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_in_progress));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->time_to_shutdown));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_audit_record));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -989,6 +1013,7 @@ static enum ndr_err_code ndr_push_lsa_AuditEventsInfo(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditing_mode));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->settings));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->settings) {
@@ -1017,6 +1042,7 @@ static enum ndr_err_code ndr_pull_lsa_AuditEventsInfo(struct ndr_pull *ndr, int
                        r->settings = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->settings) {
@@ -1070,6 +1096,7 @@ static enum ndr_err_code ndr_push_lsa_DomainInfo(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
@@ -1093,6 +1120,7 @@ static enum ndr_err_code ndr_pull_lsa_DomainInfo(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->sid = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
@@ -1125,6 +1153,7 @@ static enum ndr_err_code ndr_push_lsa_PDAccountInfo(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -1137,6 +1166,7 @@ static enum ndr_err_code ndr_pull_lsa_PDAccountInfo(struct ndr_pull *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -1182,6 +1212,7 @@ static enum ndr_err_code ndr_push_lsa_ServerRole(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_lsa_Role(ndr, NDR_SCALARS, r->role));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1193,6 +1224,7 @@ static enum ndr_err_code ndr_pull_lsa_ServerRole(struct ndr_pull *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_lsa_Role(ndr, NDR_SCALARS, &r->role));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1213,6 +1245,7 @@ static enum ndr_err_code ndr_push_lsa_ReplicaSourceInfo(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->source));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->source));
@@ -1227,6 +1260,7 @@ static enum ndr_err_code ndr_pull_lsa_ReplicaSourceInfo(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->source));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->source));
@@ -1254,6 +1288,7 @@ static enum ndr_err_code ndr_push_lsa_DefaultQuotaInfo(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_wss));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pagefile));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1270,6 +1305,7 @@ static enum ndr_err_code ndr_pull_lsa_DefaultQuotaInfo(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_wss));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pagefile));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1295,6 +1331,7 @@ static enum ndr_err_code ndr_push_lsa_ModificationInfo(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_id));
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->db_create_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1307,6 +1344,7 @@ static enum ndr_err_code ndr_pull_lsa_ModificationInfo(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_id));
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->db_create_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1327,6 +1365,7 @@ static enum ndr_err_code ndr_push_lsa_AuditFullSetInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1338,6 +1377,7 @@ static enum ndr_err_code ndr_pull_lsa_AuditFullSetInfo(struct ndr_pull *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1358,6 +1398,7 @@ static enum ndr_err_code ndr_push_lsa_AuditFullQueryInfo(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->log_is_full));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1370,6 +1411,7 @@ static enum ndr_err_code ndr_pull_lsa_AuditFullQueryInfo(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->log_is_full));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1394,6 +1436,7 @@ static enum ndr_err_code ndr_push_lsa_DnsDomainInfo(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
@@ -1422,6 +1465,7 @@ static enum ndr_err_code ndr_pull_lsa_DnsDomainInfo(struct ndr_pull *ndr, int nd
                } else {
                        r->sid = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
@@ -1456,14 +1500,14 @@ _PUBLIC_ void ndr_print_lsa_DnsDomainInfo(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_lsa_PolicyInfo(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyInfo r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_lsa_PolicyInfo(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyInfo *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -1496,6 +1540,7 @@ static enum ndr_err_code ndr_push_lsa_PolicyInformation(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case LSA_POLICY_INFO_AUDIT_LOG: {
                                NDR_CHECK(ndr_push_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
@@ -1627,6 +1672,7 @@ static enum ndr_err_code ndr_pull_lsa_PolicyInformation(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case LSA_POLICY_INFO_AUDIT_LOG: {
                                NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
@@ -1819,6 +1865,7 @@ static enum ndr_err_code ndr_push_lsa_SidPtr(struct ndr_push *ndr, int ndr_flags
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sid) {
@@ -1840,6 +1887,7 @@ static enum ndr_err_code ndr_pull_lsa_SidPtr(struct ndr_pull *ndr, int ndr_flags
                } else {
                        r->sid = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sid) {
@@ -1872,6 +1920,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidArray(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -1905,6 +1954,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidArray(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -1961,6 +2011,7 @@ static enum ndr_err_code ndr_push_lsa_DomainList(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domains) {
@@ -1991,6 +2042,7 @@ static enum ndr_err_code ndr_pull_lsa_DomainList(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->domains = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domains) {
@@ -2042,14 +2094,14 @@ _PUBLIC_ void ndr_print_lsa_DomainList(struct ndr_print *ndr, const char *name,
 
 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidType(struct ndr_push *ndr, int ndr_flags, enum lsa_SidType r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidType(struct ndr_pull *ndr, int ndr_flags, enum lsa_SidType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -2080,6 +2132,7 @@ static enum ndr_err_code ndr_push_lsa_TranslatedSid(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2093,6 +2146,7 @@ static enum ndr_err_code ndr_pull_lsa_TranslatedSid(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2116,6 +2170,7 @@ static enum ndr_err_code ndr_push_lsa_TransSidArray(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -2146,6 +2201,7 @@ static enum ndr_err_code ndr_pull_lsa_TransSidArray(struct ndr_pull *ndr, int nd
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -2200,6 +2256,7 @@ static enum ndr_err_code ndr_push_lsa_RefDomainList(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_size));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domains) {
@@ -2234,6 +2291,7 @@ static enum ndr_err_code ndr_pull_lsa_RefDomainList(struct ndr_pull *ndr, int nd
                        r->domains = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domains) {
@@ -2286,14 +2344,14 @@ _PUBLIC_ void ndr_print_lsa_RefDomainList(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_lsa_LookupNamesLevel(struct ndr_push *ndr, int ndr_flags, enum lsa_LookupNamesLevel r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_lsa_LookupNamesLevel(struct ndr_pull *ndr, int ndr_flags, enum lsa_LookupNamesLevel *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -2321,6 +2379,7 @@ static enum ndr_err_code ndr_push_lsa_TranslatedName(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -2335,6 +2394,7 @@ static enum ndr_err_code ndr_pull_lsa_TranslatedName(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -2359,6 +2419,7 @@ static enum ndr_err_code ndr_push_lsa_TransNameArray(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -2392,6 +2453,7 @@ static enum ndr_err_code ndr_pull_lsa_TransNameArray(struct ndr_pull *ndr, int n
                } else {
                        r->names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -2447,6 +2509,7 @@ static enum ndr_err_code ndr_push_lsa_LUIDAttribute(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attribute));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2459,6 +2522,7 @@ static enum ndr_err_code ndr_pull_lsa_LUIDAttribute(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attribute));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2485,6 +2549,7 @@ static enum ndr_err_code ndr_push_lsa_PrivilegeSet(struct ndr_push *ndr, int ndr
                for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
                        NDR_CHECK(ndr_push_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2513,6 +2578,7 @@ static enum ndr_err_code ndr_pull_lsa_PrivilegeSet(struct ndr_pull *ndr, int ndr
                if (r->set) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->set, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2546,9 +2612,10 @@ static enum ndr_err_code ndr_push_lsa_DATA_BUF(struct ndr_push *ndr, int ndr_fla
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 5));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -2572,14 +2639,15 @@ static enum ndr_err_code ndr_pull_lsa_DATA_BUF(struct ndr_pull *ndr, int ndr_fla
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 5));
-                       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
-                       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
+                       NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->length));
+                       NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->size));
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
                        if (_ptr_data) {
                                NDR_PULL_ALLOC(ndr, r->data);
                        } else {
                                r->data = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -2613,8 +2681,8 @@ _PUBLIC_ void ndr_print_lsa_DATA_BUF(struct ndr_print *ndr, const char *name, co
                uint32_t _flags_save_STRUCT = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                ndr->depth++;
-               ndr_print_uint32(ndr, "length", r->length);
-               ndr_print_uint32(ndr, "size", r->size);
+               ndr_print_uint3264(ndr, "length", r->length);
+               ndr_print_uint3264(ndr, "size", r->size);
                ndr_print_ptr(ndr, "data", r->data);
                ndr->depth++;
                if (r->data) {
@@ -2635,6 +2703,7 @@ static enum ndr_err_code ndr_push_lsa_DATA_BUF2(struct ndr_push *ndr, int ndr_fl
                        NDR_CHECK(ndr_push_align(ndr, 5));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -2666,6 +2735,7 @@ static enum ndr_err_code ndr_pull_lsa_DATA_BUF2(struct ndr_pull *ndr, int ndr_fl
                        } else {
                                r->data = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -2706,14 +2776,14 @@ _PUBLIC_ void ndr_print_lsa_DATA_BUF2(struct ndr_print *ndr, const char *name, c
 
 static enum ndr_err_code ndr_push_lsa_TrustDomInfoEnum(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_lsa_TrustDomInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -2823,6 +2893,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoName(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
@@ -2835,6 +2906,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoName(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
@@ -2857,6 +2929,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoControllers(struct ndr_push
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_names) {
@@ -2887,6 +2960,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoControllers(struct ndr_pull
                } else {
                        r->netbios_names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_names) {
@@ -2941,6 +3015,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPosixOffset(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->posix_offset));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2952,6 +3027,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPosixOffset(struct ndr_pull
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->posix_offset));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2972,6 +3048,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPassword(struct ndr_push *n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->old_password));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->password) {
@@ -3004,6 +3081,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPassword(struct ndr_pull *n
                } else {
                        r->old_password = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->password) {
@@ -3047,6 +3125,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBasic(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
@@ -3070,6 +3149,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBasic(struct ndr_pull *ndr,
                } else {
                        r->sid = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
@@ -3107,6 +3187,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoEx(struct ndr_push *ndr
                NDR_CHECK(ndr_push_lsa_TrustDirection(ndr, NDR_SCALARS, r->trust_direction));
                NDR_CHECK(ndr_push_lsa_TrustType(ndr, NDR_SCALARS, r->trust_type));
                NDR_CHECK(ndr_push_lsa_TrustAttributes(ndr, NDR_SCALARS, r->trust_attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
@@ -3135,6 +3216,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoEx(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_lsa_TrustDirection(ndr, NDR_SCALARS, &r->trust_direction));
                NDR_CHECK(ndr_pull_lsa_TrustType(ndr, NDR_SCALARS, &r->trust_type));
                NDR_CHECK(ndr_pull_lsa_TrustAttributes(ndr, NDR_SCALARS, &r->trust_attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
@@ -3201,6 +3283,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBuffer(struct ndr_push *ndr
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_update_time));
                NDR_CHECK(ndr_push_lsa_TrustAuthType(ndr, NDR_SCALARS, r->AuthType));
                NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
@@ -3215,6 +3298,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBuffer(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_update_time));
                NDR_CHECK(ndr_pull_lsa_TrustAuthType(ndr, NDR_SCALARS, &r->AuthType));
                NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
@@ -3242,6 +3326,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoAuthInfo(struct ndr_push *n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->outgoing_count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_current_auth_info));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_previous_auth_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->incoming_current_auth_info) {
@@ -3298,6 +3383,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoAuthInfo(struct ndr_pull *n
                } else {
                        r->outgoing_previous_auth_info = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->incoming_current_auth_info) {
@@ -3368,6 +3454,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfo(struct ndr_push *n
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
@@ -3383,6 +3470,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfo(struct ndr_pull *n
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
@@ -3406,6 +3494,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoAuthInfoInternal(struct ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->auth_blob));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->auth_blob));
@@ -3418,6 +3507,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(struct ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->auth_blob));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->auth_blob));
@@ -3440,6 +3530,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfoInternal(struct ndr
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS, &r->auth_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
@@ -3455,6 +3546,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfoInternal(struct ndr
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS, &r->auth_info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
@@ -3480,6 +3572,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoEx2Internal(struct ndr_
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->forest_trust_length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->forest_trust_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
@@ -3505,6 +3598,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(struct ndr_
                } else {
                        r->forest_trust_data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
@@ -3545,6 +3639,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfo2Internal(struct nd
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_BUFFERS, &r->info));
@@ -3560,6 +3655,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfo2Internal(struct nd
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_BUFFERS, &r->info));
@@ -3583,6 +3679,7 @@ static enum ndr_err_code ndr_push_lsa_TrustDomainInfoSupportedEncTypes(struct nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_kerb_EncTypes(ndr, NDR_SCALARS, r->enc_types));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3594,6 +3691,7 @@ static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoSupportedEncTypes(struct nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_kerb_EncTypes(ndr, NDR_SCALARS, &r->enc_types));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3613,6 +3711,7 @@ static enum ndr_err_code ndr_push_lsa_TrustedDomainInfo(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case LSA_TRUSTED_DOMAIN_INFO_NAME: {
                                NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
@@ -3736,10 +3835,11 @@ static enum ndr_err_code ndr_pull_lsa_TrustedDomainInfo(struct ndr_pull *ndr, in
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case LSA_TRUSTED_DOMAIN_INFO_NAME: {
                                NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
@@ -3924,6 +4024,7 @@ static enum ndr_err_code ndr_push_lsa_DATA_BUF_PTR(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->buf));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->buf) {
@@ -3945,6 +4046,7 @@ static enum ndr_err_code ndr_pull_lsa_DATA_BUF_PTR(struct ndr_pull *ndr, int ndr
                } else {
                        r->buf = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->buf) {
@@ -3977,6 +4079,7 @@ static enum ndr_err_code ndr_push_lsa_RightSet(struct ndr_push *ndr, int ndr_fla
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -4010,6 +4113,7 @@ static enum ndr_err_code ndr_pull_lsa_RightSet(struct ndr_pull *ndr, int ndr_fla
                } else {
                        r->names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -4066,6 +4170,7 @@ static enum ndr_err_code ndr_push_lsa_DomainListEx(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domains) {
@@ -4096,6 +4201,7 @@ static enum ndr_err_code ndr_pull_lsa_DomainListEx(struct ndr_pull *ndr, int ndr
                } else {
                        r->domains = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domains) {
@@ -4155,6 +4261,7 @@ static enum ndr_err_code ndr_push_lsa_DomainInfoKerberos(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_renewaltime));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->clock_skew));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4171,6 +4278,7 @@ static enum ndr_err_code ndr_pull_lsa_DomainInfoKerberos(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_renewaltime));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->clock_skew));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4196,6 +4304,7 @@ static enum ndr_err_code ndr_push_lsa_DomainInfoEfs(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->efs_blob));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->efs_blob) {
@@ -4219,6 +4328,7 @@ static enum ndr_err_code ndr_pull_lsa_DomainInfoEfs(struct ndr_pull *ndr, int nd
                } else {
                        r->efs_blob = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->efs_blob) {
@@ -4255,6 +4365,7 @@ static enum ndr_err_code ndr_push_lsa_DomainInformationPolicy(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case LSA_DOMAIN_INFO_POLICY_EFS: {
                                NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
@@ -4295,6 +4406,7 @@ static enum ndr_err_code ndr_pull_lsa_DomainInformationPolicy(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case LSA_DOMAIN_INFO_POLICY_EFS: {
                                NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
@@ -4351,6 +4463,7 @@ static enum ndr_err_code ndr_push_lsa_TranslatedName2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -4366,6 +4479,7 @@ static enum ndr_err_code ndr_pull_lsa_TranslatedName2(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -4391,6 +4505,7 @@ static enum ndr_err_code ndr_push_lsa_TransNameArray2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -4424,6 +4539,7 @@ static enum ndr_err_code ndr_pull_lsa_TransNameArray2(struct ndr_pull *ndr, int
                } else {
                        r->names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -4531,6 +4647,7 @@ static enum ndr_err_code ndr_push_lsa_TranslatedSid2(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4545,6 +4662,7 @@ static enum ndr_err_code ndr_pull_lsa_TranslatedSid2(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4569,6 +4687,7 @@ static enum ndr_err_code ndr_push_lsa_TransSidArray2(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -4599,6 +4718,7 @@ static enum ndr_err_code ndr_pull_lsa_TransSidArray2(struct ndr_pull *ndr, int n
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -4653,6 +4773,7 @@ static enum ndr_err_code ndr_push_lsa_TranslatedSid3(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sid) {
@@ -4677,6 +4798,7 @@ static enum ndr_err_code ndr_pull_lsa_TranslatedSid3(struct ndr_pull *ndr, int n
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sid) {
@@ -4712,6 +4834,7 @@ static enum ndr_err_code ndr_push_lsa_TransSidArray3(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -4745,6 +4868,7 @@ static enum ndr_err_code ndr_pull_lsa_TransSidArray3(struct ndr_pull *ndr, int n
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sids) {
@@ -4798,8 +4922,9 @@ static enum ndr_err_code ndr_push_lsa_ForestTrustBinaryData(struct ndr_push *ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -4816,7 +4941,7 @@ static enum ndr_err_code ndr_pull_lsa_ForestTrustBinaryData(struct ndr_pull *ndr
        TALLOC_CTX *_mem_save_data_0;
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
+               NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->length));
                if (r->length > 131072) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
@@ -4826,6 +4951,7 @@ static enum ndr_err_code ndr_pull_lsa_ForestTrustBinaryData(struct ndr_pull *ndr
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -4847,7 +4973,7 @@ _PUBLIC_ void ndr_print_lsa_ForestTrustBinaryData(struct ndr_print *ndr, const c
 {
        ndr_print_struct(ndr, name, "lsa_ForestTrustBinaryData");
        ndr->depth++;
-       ndr_print_uint32(ndr, "length", r->length);
+       ndr_print_uint3264(ndr, "length", r->length);
        ndr_print_ptr(ndr, "data", r->data);
        ndr->depth++;
        if (r->data) {
@@ -4864,6 +4990,7 @@ static enum ndr_err_code ndr_push_lsa_ForestTrustDomainInfo(struct ndr_push *ndr
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain_sid) {
@@ -4889,6 +5016,7 @@ static enum ndr_err_code ndr_pull_lsa_ForestTrustDomainInfo(struct ndr_pull *ndr
                }
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain_sid) {
@@ -4923,6 +5051,7 @@ static enum ndr_err_code ndr_push_lsa_ForestTrustData(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
@@ -4976,6 +5105,7 @@ static enum ndr_err_code ndr_pull_lsa_ForestTrustData(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
@@ -5079,6 +5209,7 @@ static enum ndr_err_code ndr_push_lsa_ForestTrustRecord(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->forest_trust_data, r->level));
                NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
@@ -5095,6 +5226,7 @@ static enum ndr_err_code ndr_pull_lsa_ForestTrustRecord(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->forest_trust_data, r->level));
                NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
@@ -5121,6 +5253,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_lsa_ForestTrustInformation(struct ndr_push *
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -5157,6 +5290,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_lsa_ForestTrustInformation(struct ndr_pull *
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {

diff --git a/librpc/gen_ndr/ndr_misc.c b/librpc/gen_ndr/ndr_misc.c
index fbef5094a5196d91579ca0d938fe1ba583be0138..ff79baa3825cddf2ad5356dbeca8ca10bc56f884 100644 (file)
--- a/librpc/gen_ndr/ndr_misc.c
+++ b/librpc/gen_ndr/ndr_misc.c
@@ -12,6 +12,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_GUID(struct ndr_push *ndr, int ndr_flags, co
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->time_hi_and_version));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->clock_seq, 2));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->node, 6));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -27,6 +28,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_GUID(struct ndr_pull *ndr, int ndr_flags, st
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->time_hi_and_version));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->clock_seq, 2));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->node, 6));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -44,6 +46,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ndr_syntax_id(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->if_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -56,6 +59,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ndr_syntax_id(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->if_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -77,6 +81,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_policy_handle(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->handle_type));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -89,6 +94,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_policy_handle(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->handle_type));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -106,14 +112,14 @@ _PUBLIC_ void ndr_print_policy_handle(struct ndr_print *ndr, const char *name, c
 
 _PUBLIC_ enum ndr_err_code ndr_push_netr_SchannelType(struct ndr_push *ndr, int ndr_flags, enum netr_SchannelType r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 _PUBLIC_ enum ndr_err_code ndr_pull_netr_SchannelType(struct ndr_pull *ndr, int ndr_flags, enum netr_SchannelType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -139,6 +145,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_KRB5_EDATA_NTSTATUS(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->ntstatus));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -152,6 +159,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_KRB5_EDATA_NTSTATUS(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->ntstatus));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -168,3 +176,224 @@ _PUBLIC_ void ndr_print_KRB5_EDATA_NTSTATUS(struct ndr_print *ndr, const char *n
        ndr->depth--;
 }
 
+_PUBLIC_ enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case REG_NONE: val = "REG_NONE"; break;
+               case REG_SZ: val = "REG_SZ"; break;
+               case REG_EXPAND_SZ: val = "REG_EXPAND_SZ"; break;
+               case REG_BINARY: val = "REG_BINARY"; break;
+               case REG_DWORD: val = "REG_DWORD"; break;
+               case REG_DWORD_BIG_ENDIAN: val = "REG_DWORD_BIG_ENDIAN"; break;
+               case REG_LINK: val = "REG_LINK"; break;
+               case REG_MULTI_SZ: val = "REG_MULTI_SZ"; break;
+               case REG_RESOURCE_LIST: val = "REG_RESOURCE_LIST"; break;
+               case REG_FULL_RESOURCE_DESCRIPTOR: val = "REG_FULL_RESOURCE_DESCRIPTOR"; break;
+               case REG_RESOURCE_REQUIREMENTS_LIST: val = "REG_RESOURCE_REQUIREMENTS_LIST"; break;
+               case REG_QWORD: val = "REG_QWORD"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_winreg_Data(struct ndr_push *ndr, int ndr_flags, const union winreg_Data *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
+               switch (level) {
+                       case REG_NONE: {
+                       break; }
+
+                       case REG_SZ: {
+                               {
+                                       uint32_t _flags_save_string = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                                       NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
+                                       ndr->flags = _flags_save_string;
+                               }
+                       break; }
+
+                       case REG_BINARY: {
+                               {
+                                       uint32_t _flags_save_DATA_BLOB = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+                                       NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
+                                       ndr->flags = _flags_save_DATA_BLOB;
+                               }
+                       break; }
+
+                       case REG_DWORD: {
+                               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
+                       break; }
+
+                       case REG_MULTI_SZ: {
+                               {
+                                       uint32_t _flags_save_string_array = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                                       NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
+                                       ndr->flags = _flags_save_string_array;
+                               }
+                       break; }
+
+                       default: {
+                               {
+                                       uint32_t _flags_save_DATA_BLOB = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+                                       NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
+                                       ndr->flags = _flags_save_DATA_BLOB;
+                               }
+                       break; }
+
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               switch (level) {
+                       case REG_NONE:
+                       break;
+
+                       case REG_SZ:
+                       break;
+
+                       case REG_BINARY:
+                       break;
+
+                       case REG_DWORD:
+                       break;
+
+                       case REG_MULTI_SZ:
+                       break;
+
+                       default:
+                       break;
+
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r)
+{
+       int level;
+       level = ndr_pull_get_switch_value(ndr, r);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
+               switch (level) {
+                       case REG_NONE: {
+                       break; }
+
+                       case REG_SZ: {
+                               {
+                                       uint32_t _flags_save_string = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                                       NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
+                                       ndr->flags = _flags_save_string;
+                               }
+                       break; }
+
+                       case REG_BINARY: {
+                               {
+                                       uint32_t _flags_save_DATA_BLOB = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+                                       NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
+                                       ndr->flags = _flags_save_DATA_BLOB;
+                               }
+                       break; }
+
+                       case REG_DWORD: {
+                               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
+                       break; }
+
+                       case REG_MULTI_SZ: {
+                               {
+                                       uint32_t _flags_save_string_array = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                                       NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
+                                       ndr->flags = _flags_save_string_array;
+                               }
+                       break; }
+
+                       default: {
+                               {
+                                       uint32_t _flags_save_DATA_BLOB = ndr->flags;
+                                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+                                       NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
+                                       ndr->flags = _flags_save_DATA_BLOB;
+                               }
+                       break; }
+
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               switch (level) {
+                       case REG_NONE:
+                       break;
+
+                       case REG_SZ:
+                       break;
+
+                       case REG_BINARY:
+                       break;
+
+                       case REG_DWORD:
+                       break;
+
+                       case REG_MULTI_SZ:
+                       break;
+
+                       default:
+                       break;
+
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_winreg_Data(struct ndr_print *ndr, const char *name, const union winreg_Data *r)
+{
+       int level;
+       level = ndr_print_get_switch_value(ndr, r);
+       ndr_print_union(ndr, name, level, "winreg_Data");
+       switch (level) {
+               case REG_NONE:
+               break;
+
+               case REG_SZ:
+                       ndr_print_string(ndr, "string", r->string);
+               break;
+
+               case REG_BINARY:
+                       ndr_print_DATA_BLOB(ndr, "binary", r->binary);
+               break;
+
+               case REG_DWORD:
+                       ndr_print_uint32(ndr, "value", r->value);
+               break;
+
+               case REG_MULTI_SZ:
+                       ndr_print_string_array(ndr, "string_array", r->string_array);
+               break;
+
+               default:
+                       ndr_print_DATA_BLOB(ndr, "data", r->data);
+               break;
+
+       }
+}
+

diff --git a/librpc/gen_ndr/ndr_misc.h b/librpc/gen_ndr/ndr_misc.h
index 938c946b73b16f3d4ea38c3a42ffaec1d7e9ad02..99f975208a1a8c806ce53ef5321722f71fff7709 100644 (file)
--- a/librpc/gen_ndr/ndr_misc.h
+++ b/librpc/gen_ndr/ndr_misc.h
@@ -23,4 +23,10 @@ void ndr_print_netr_SchannelType(struct ndr_print *ndr, const char *name, enum n
 enum ndr_err_code ndr_push_KRB5_EDATA_NTSTATUS(struct ndr_push *ndr, int ndr_flags, const struct KRB5_EDATA_NTSTATUS *r);
 enum ndr_err_code ndr_pull_KRB5_EDATA_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, struct KRB5_EDATA_NTSTATUS *r);
 void ndr_print_KRB5_EDATA_NTSTATUS(struct ndr_print *ndr, const char *name, const struct KRB5_EDATA_NTSTATUS *r);
+enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r);
+enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r);
+void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r);
+enum ndr_err_code ndr_push_winreg_Data(struct ndr_push *ndr, int ndr_flags, const union winreg_Data *r);
+enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r);
+void ndr_print_winreg_Data(struct ndr_print *ndr, const char *name, const union winreg_Data *r);
 #endif /* _HEADER_NDR_misc */

diff --git a/librpc/gen_ndr/ndr_named_pipe_auth.c b/librpc/gen_ndr/ndr_named_pipe_auth.c
index cdd8a3d64145c7640b7e7a93e37161ae62a42a0c..18eadf9237304183e68eb696ada4a874f06e737f 100644 (file)
--- a/librpc/gen_ndr/ndr_named_pipe_auth.c
+++ b/librpc/gen_ndr/ndr_named_pipe_auth.c
@@ -17,6 +17,7 @@ static enum ndr_err_code ndr_push_named_pipe_auth_req_info2(struct ndr_push *ndr
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sam_info3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_key_length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->session_key));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_name) {
@@ -109,6 +110,7 @@ static enum ndr_err_code ndr_pull_named_pipe_auth_req_info2(struct ndr_pull *ndr
                } else {
                        r->session_key = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_name) {
@@ -241,6 +243,7 @@ static enum ndr_err_code ndr_push_named_pipe_auth_req_info3(struct ndr_push *ndr
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->session_key));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->gssapi_delegated_creds_length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->gssapi_delegated_creds));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_name) {
@@ -346,6 +349,7 @@ static enum ndr_err_code ndr_pull_named_pipe_auth_req_info3(struct ndr_pull *ndr
                } else {
                        r->gssapi_delegated_creds = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_name) {
@@ -486,6 +490,7 @@ static enum ndr_err_code ndr_push_named_pipe_auth_req_info(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                        break; }
@@ -541,6 +546,7 @@ static enum ndr_err_code ndr_pull_named_pipe_auth_req_info(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                        break; }
@@ -625,6 +631,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_named_pipe_auth_req(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_push_named_pipe_auth_req_info(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_named_pipe_auth_req_info(ndr, NDR_BUFFERS, &r->info));
@@ -646,6 +653,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_named_pipe_auth_req(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_pull_named_pipe_auth_req_info(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_named_pipe_auth_req_info(ndr, NDR_BUFFERS, &r->info));
@@ -677,6 +685,7 @@ static enum ndr_err_code ndr_push_named_pipe_auth_rep_info2(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->file_type));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->device_state));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->allocation_size));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -690,6 +699,7 @@ static enum ndr_err_code ndr_pull_named_pipe_auth_rep_info2(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->file_type));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->device_state));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->allocation_size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -713,6 +723,7 @@ static enum ndr_err_code ndr_push_named_pipe_auth_rep_info3(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->file_type));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->device_state));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->allocation_size));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -726,6 +737,7 @@ static enum ndr_err_code ndr_pull_named_pipe_auth_rep_info3(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->file_type));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->device_state));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->allocation_size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -747,6 +759,7 @@ static enum ndr_err_code ndr_push_named_pipe_auth_rep_info(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 0: {
                        break; }
@@ -798,6 +811,7 @@ static enum ndr_err_code ndr_pull_named_pipe_auth_rep_info(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 0: {
                        break; }
@@ -878,6 +892,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_named_pipe_auth_rep(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_push_named_pipe_auth_rep_info(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_named_pipe_auth_rep_info(ndr, NDR_BUFFERS, &r->info));
@@ -900,6 +915,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_named_pipe_auth_rep(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_pull_named_pipe_auth_rep_info(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_named_pipe_auth_rep_info(ndr, NDR_BUFFERS, &r->info));

diff --git a/librpc/gen_ndr/ndr_nbt.c b/librpc/gen_ndr/ndr_nbt.c
index a1ee79686f46b43e450c43f6b73bdf9fdfba9d76..dc9e8cb8d36e5a9c59110a41d4b36564a5dd0fa4 100644 (file)
--- a/librpc/gen_ndr/ndr_nbt.c
+++ b/librpc/gen_ndr/ndr_nbt.c
@@ -136,6 +136,7 @@ static enum ndr_err_code ndr_push_nbt_name_question(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_push_nbt_qtype(ndr, NDR_SCALARS, r->question_type));
                NDR_CHECK(ndr_push_nbt_qclass(ndr, NDR_SCALARS, r->question_class));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -149,6 +150,7 @@ static enum ndr_err_code ndr_pull_nbt_name_question(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_pull_nbt_qtype(ndr, NDR_SCALARS, &r->question_type));
                NDR_CHECK(ndr_pull_nbt_qclass(ndr, NDR_SCALARS, &r->question_class));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -198,6 +200,7 @@ static enum ndr_err_code ndr_push_nbt_rdata_address(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_nb_flags(ndr, NDR_SCALARS, r->nb_flags));
                NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipaddr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -210,6 +213,7 @@ static enum ndr_err_code ndr_pull_nbt_rdata_address(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_nb_flags(ndr, NDR_SCALARS, &r->nb_flags));
                NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipaddr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -234,6 +238,7 @@ static enum ndr_err_code ndr_push_nbt_rdata_netbios(struct ndr_push *ndr, int nd
                for (cntr_addresses_0 = 0; cntr_addresses_0 < r->length / 6; cntr_addresses_0++) {
                        NDR_CHECK(ndr_push_nbt_rdata_address(ndr, NDR_SCALARS, &r->addresses[cntr_addresses_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -254,6 +259,7 @@ static enum ndr_err_code ndr_pull_nbt_rdata_netbios(struct ndr_pull *ndr, int nd
                        NDR_CHECK(ndr_pull_nbt_rdata_address(ndr, NDR_SCALARS, &r->addresses[cntr_addresses_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addresses_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -303,6 +309,7 @@ static enum ndr_err_code ndr_push_nbt_statistics(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_number_pending_sessions));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_total_sessions_possible));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->session_data_packet_size));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -333,6 +340,7 @@ static enum ndr_err_code ndr_pull_nbt_statistics(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_number_pending_sessions));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_total_sessions_possible));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->session_data_packet_size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -373,6 +381,7 @@ static enum ndr_err_code ndr_push_nbt_status_name(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 15, sizeof(uint8_t), CH_DOS));
                NDR_CHECK(ndr_push_nbt_name_type(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_nb_flags(ndr, NDR_SCALARS, r->nb_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -386,6 +395,7 @@ static enum ndr_err_code ndr_pull_nbt_status_name(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, 15, sizeof(uint8_t), CH_DOS));
                NDR_CHECK(ndr_pull_nbt_name_type(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_pull_nb_flags(ndr, NDR_SCALARS, &r->nb_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -413,6 +423,7 @@ static enum ndr_err_code ndr_push_nbt_rdata_status(struct ndr_push *ndr, int ndr
                        NDR_CHECK(ndr_push_nbt_status_name(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
                }
                NDR_CHECK(ndr_push_nbt_statistics(ndr, NDR_SCALARS, &r->statistics));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -435,6 +446,7 @@ static enum ndr_err_code ndr_pull_nbt_rdata_status(struct ndr_pull *ndr, int ndr
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
                NDR_CHECK(ndr_pull_nbt_statistics(ndr, NDR_SCALARS, &r->statistics));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -468,6 +480,7 @@ static enum ndr_err_code ndr_push_nbt_rdata_data(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -481,6 +494,7 @@ static enum ndr_err_code ndr_pull_nbt_rdata_data(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
                NDR_PULL_ALLOC_N(ndr, r->data, r->length);
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -500,6 +514,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_rdata(struct ndr_push *ndr, int ndr_flag
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case NBT_QTYPE_NETBIOS: {
                                NDR_CHECK(ndr_push_nbt_rdata_netbios(ndr, NDR_SCALARS, &r->netbios));
@@ -537,6 +552,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_rdata(struct ndr_pull *ndr, int ndr_flag
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case NBT_QTYPE_NETBIOS: {
                                NDR_CHECK(ndr_pull_nbt_rdata_netbios(ndr, NDR_SCALARS, &r->netbios));
@@ -602,6 +618,7 @@ static enum ndr_err_code ndr_pull_nbt_res_rec(struct ndr_pull *ndr, int ndr_flag
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata, r->rr_type));
                        NDR_CHECK(ndr_pull_nbt_rdata(ndr, NDR_SCALARS, &r->rdata));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -663,6 +680,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_name_packet(struct ndr_push *ndr, int nd
                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->padding));
                                ndr->flags = _flags_save_DATA_BLOB;
                        }
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -726,6 +744,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_name_packet(struct ndr_pull *ndr, int nd
                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->padding));
                                ndr->flags = _flags_save_DATA_BLOB;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -911,6 +930,7 @@ static enum ndr_err_code ndr_push_smb_trans_body(struct ndr_push *ndr, int ndr_f
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -959,6 +979,7 @@ static enum ndr_err_code ndr_pull_smb_trans_body(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -998,6 +1019,7 @@ static enum ndr_err_code ndr_push_smb_body(struct ndr_push *ndr, int ndr_flags,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case SMB_TRANSACTION: {
                                NDR_CHECK(ndr_push_smb_trans_body(ndr, NDR_SCALARS, &r->trans));
@@ -1025,6 +1047,7 @@ static enum ndr_err_code ndr_pull_smb_body(struct ndr_pull *ndr, int ndr_flags,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case SMB_TRANSACTION: {
                                NDR_CHECK(ndr_pull_smb_trans_body(ndr, NDR_SCALARS, &r->trans));
@@ -1083,6 +1106,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dgram_smb_packet(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->mid));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->body, r->smb_command));
                        NDR_CHECK(ndr_push_smb_body(ndr, NDR_SCALARS, &r->body));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1113,6 +1137,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dgram_smb_packet(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->mid));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->body, r->smb_command));
                        NDR_CHECK(ndr_pull_smb_body(ndr, NDR_SCALARS, &r->body));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1152,6 +1177,7 @@ static enum ndr_err_code ndr_push_dgram_message_body(struct ndr_push *ndr, int n
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case DGRAM_SMB: {
                                NDR_CHECK(ndr_push_dgram_smb_packet(ndr, NDR_SCALARS, &r->smb));
@@ -1179,6 +1205,7 @@ static enum ndr_err_code ndr_pull_dgram_message_body(struct ndr_pull *ndr, int n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case DGRAM_SMB: {
                                NDR_CHECK(ndr_pull_dgram_smb_packet(ndr, NDR_SCALARS, &r->smb));
@@ -1226,6 +1253,7 @@ static enum ndr_err_code ndr_push_dgram_message(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_body_type));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->body, r->dgram_body_type));
                NDR_CHECK(ndr_push_dgram_message_body(ndr, NDR_SCALARS, &r->body));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1243,6 +1271,7 @@ static enum ndr_err_code ndr_pull_dgram_message(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_body_type));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->body, r->dgram_body_type));
                NDR_CHECK(ndr_pull_dgram_message_body(ndr, NDR_SCALARS, &r->body));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1293,6 +1322,7 @@ static enum ndr_err_code ndr_push_dgram_data(struct ndr_push *ndr, int ndr_flags
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case DGRAM_DIRECT_UNIQUE: {
                                NDR_CHECK(ndr_push_dgram_message(ndr, NDR_SCALARS, &r->msg));
@@ -1362,6 +1392,7 @@ static enum ndr_err_code ndr_pull_dgram_data(struct ndr_pull *ndr, int ndr_flags
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case DGRAM_DIRECT_UNIQUE: {
                                NDR_CHECK(ndr_pull_dgram_message(ndr, NDR_SCALARS, &r->msg));
@@ -1478,6 +1509,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_dgram_packet(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->src_port));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->msg_type));
                        NDR_CHECK(ndr_push_dgram_data(ndr, NDR_SCALARS, &r->data));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1500,6 +1532,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_dgram_packet(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->src_port));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->msg_type));
                        NDR_CHECK(ndr_pull_dgram_data(ndr, NDR_SCALARS, &r->data));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1544,6 +1577,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_sockaddr(struct ndr_push *ndr, int ndr_f
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1567,6 +1601,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_sockaddr(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1618,7 +1653,10 @@ _PUBLIC_ void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name,
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_NDNC", NBT_SERVER_NDNC, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_SELECT_SECRET_DOMAIN_6", NBT_SERVER_SELECT_SECRET_DOMAIN_6, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_FULL_SECRET_DOMAIN_6", NBT_SERVER_FULL_SECRET_DOMAIN_6, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_DNS_FOREST", NBT_SERVER_DNS_FOREST, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_ADS_WEB_SERVICE", NBT_SERVER_ADS_WEB_SERVICE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_HAS_DNS_NAME", NBT_SERVER_HAS_DNS_NAME, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_IS_DEFAULT_NC", NBT_SERVER_IS_DEFAULT_NC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_FOREST_ROOT", NBT_SERVER_FOREST_ROOT, r);
        ndr->depth--;
 }
 
@@ -1733,6 +1771,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1770,6 +1809,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1833,6 +1873,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_push
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1877,6 +1918,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_pull
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1941,6 +1983,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_pu
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1979,6 +2022,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_pu
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2048,6 +2092,7 @@ static enum ndr_err_code ndr_push_nbt_netlogon_query_for_pdc(struct ndr_push *nd
                NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2085,6 +2130,7 @@ static enum ndr_err_code ndr_pull_nbt_netlogon_query_for_pdc(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2140,6 +2186,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_response_from_pdc(struct ndr_pu
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2183,6 +2230,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_response_from_pdc(struct ndr_pu
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2218,6 +2266,7 @@ static enum ndr_err_code ndr_push_nbt_db_change_info(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_netr_SamDatabaseID(ndr, NDR_SCALARS, r->db_index));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->serial));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2231,6 +2280,7 @@ static enum ndr_err_code ndr_pull_nbt_db_change_info(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_netr_SamDatabaseID(ndr, NDR_SCALARS, &r->db_index));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->serial));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2299,6 +2349,7 @@ static enum ndr_err_code ndr_push_NETLOGON_DB_CHANGE(struct ndr_push *ndr, int n
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->message_format_version));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->message_token));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2362,6 +2413,7 @@ static enum ndr_err_code ndr_pull_NETLOGON_DB_CHANGE(struct ndr_pull *ndr, int n
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->message_format_version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->message_token));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2404,6 +2456,7 @@ static enum ndr_err_code ndr_push_nbt_netlogon_request(struct ndr_push *ndr, int
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case LOGON_SAM_LOGON_REQUEST: {
                                NDR_CHECK(ndr_push_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_SCALARS, &r->logon));
@@ -2447,6 +2500,7 @@ static enum ndr_err_code ndr_pull_nbt_netlogon_request(struct ndr_pull *ndr, int
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case LOGON_SAM_LOGON_REQUEST: {
                                NDR_CHECK(ndr_pull_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_SCALARS, &r->logon));
@@ -2517,6 +2571,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_packet(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->req, r->command));
                        NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 8));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
@@ -2536,6 +2591,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_packet(struct ndr_pull *ndr, in
                        NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->req, r->command));
                        NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
@@ -2612,6 +2668,7 @@ static enum ndr_err_code ndr_push_nbt_browse_host_announcement(struct ndr_push *
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2637,6 +2694,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_host_announcement(struct ndr_pull *
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2671,6 +2729,7 @@ static enum ndr_err_code ndr_push_nbt_browse_announcement_request(struct ndr_pus
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->ResponseName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2688,6 +2747,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_announcement_request(struct ndr_pul
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->ResponseName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2717,6 +2777,7 @@ static enum ndr_err_code ndr_push_nbt_browse_election_request(struct ndr_push *n
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->ServerName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2737,6 +2798,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_election_request(struct ndr_pull *n
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->ServerName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2761,6 +2823,7 @@ static enum ndr_err_code ndr_push_nbt_browse_backup_list_request(struct ndr_push
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ReqCount));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Token));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2773,6 +2836,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_backup_list_request(struct ndr_pull
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ReqCount));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Token));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2798,6 +2862,7 @@ static enum ndr_err_code ndr_push_nbt_browse_backup_list_response(struct ndr_pus
                for (cntr_BackupServerList_0 = 0; cntr_BackupServerList_0 < r->BackupCount; cntr_BackupServerList_0++) {
                        NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->BackupServerList[cntr_BackupServerList_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2819,6 +2884,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_backup_list_response(struct ndr_pul
                        NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->BackupServerList[cntr_BackupServerList_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_BackupServerList_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2855,6 +2921,7 @@ static enum ndr_err_code ndr_push_nbt_browse_become_backup(struct ndr_push *ndr,
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->BrowserName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2871,6 +2938,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_become_backup(struct ndr_pull *ndr,
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->BrowserName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2902,6 +2970,7 @@ static enum ndr_err_code ndr_push_nbt_browse_domain_announcement(struct ndr_push
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2925,6 +2994,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_domain_announcement(struct ndr_pull
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2956,6 +3026,7 @@ static enum ndr_err_code ndr_push_nbt_browse_master_announcement(struct ndr_push
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->ServerName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2972,6 +3043,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_master_announcement(struct ndr_pull
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->ServerName));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2991,6 +3063,7 @@ static enum ndr_err_code ndr_push_nbt_browse_reset_state(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->Command));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3002,6 +3075,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_reset_state(struct ndr_pull *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->Command));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3035,6 +3109,7 @@ static enum ndr_err_code ndr_push_nbt_browse_local_master_announcement(struct nd
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3060,6 +3135,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_local_master_announcement(struct nd
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3087,6 +3163,7 @@ static enum ndr_err_code ndr_push_nbt_browse_payload(struct ndr_push *ndr, int n
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case HostAnnouncement: {
                                NDR_CHECK(ndr_push_nbt_browse_host_announcement(ndr, NDR_SCALARS, &r->host_annoucement));
@@ -3177,6 +3254,7 @@ static enum ndr_err_code ndr_pull_nbt_browse_payload(struct ndr_pull *ndr, int n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case HostAnnouncement: {
                                NDR_CHECK(ndr_pull_nbt_browse_host_announcement(ndr, NDR_SCALARS, &r->host_annoucement));
@@ -3322,6 +3400,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_nbt_browse_packet(struct ndr_push *ndr, int
                        NDR_CHECK(ndr_push_nbt_browse_opcode(ndr, NDR_SCALARS, r->opcode));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->payload, r->opcode));
                        NDR_CHECK(ndr_push_nbt_browse_payload(ndr, NDR_SCALARS, &r->payload));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -3340,6 +3419,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_nbt_browse_packet(struct ndr_pull *ndr, int
                        NDR_CHECK(ndr_pull_nbt_browse_opcode(ndr, NDR_SCALARS, &r->opcode));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->payload, r->opcode));
                        NDR_CHECK(ndr_pull_nbt_browse_payload(ndr, NDR_SCALARS, &r->payload));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }

diff --git a/librpc/gen_ndr/ndr_netlogon.c b/librpc/gen_ndr/ndr_netlogon.c
index 0013cf4d68cbd61fa2cd9a85f711c5b070273b09..ceb71980277e93c648dc44df30131191903d1fbc 100644 (file)
--- a/librpc/gen_ndr/ndr_netlogon.c
+++ b/librpc/gen_ndr/ndr_netlogon.c
@@ -28,6 +28,7 @@ static enum ndr_err_code ndr_push_netr_UasInfo(struct ndr_push *ndr, int ndr_fla
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->script_path));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->account_name) {
@@ -106,6 +107,7 @@ static enum ndr_err_code ndr_pull_netr_UasInfo(struct ndr_pull *ndr, int ndr_fla
                        r->script_path = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->account_name) {
@@ -209,6 +211,7 @@ static enum ndr_err_code ndr_push_netr_UasLogoffInfo(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->duration));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -221,6 +224,7 @@ static enum ndr_err_code ndr_pull_netr_UasLogoffInfo(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->duration));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -244,6 +248,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_AcctLockStr(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reset_count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_attempt_lockout));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -258,6 +263,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_AcctLockStr(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reset_count));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_attempt_lockout));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -325,6 +331,7 @@ static enum ndr_err_code ndr_push_netr_IdentityInfo(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logon_id_high));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstation));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -344,6 +351,7 @@ static enum ndr_err_code ndr_pull_netr_IdentityInfo(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logon_id_high));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstation));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -373,6 +381,7 @@ static enum ndr_err_code ndr_push_netr_PasswordInfo(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_netr_IdentityInfo(ndr, NDR_SCALARS, &r->identity_info));
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lmpassword));
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->ntpassword));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_IdentityInfo(ndr, NDR_BUFFERS, &r->identity_info));
@@ -387,6 +396,7 @@ static enum ndr_err_code ndr_pull_netr_PasswordInfo(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_netr_IdentityInfo(ndr, NDR_SCALARS, &r->identity_info));
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lmpassword));
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->ntpassword));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_IdentityInfo(ndr, NDR_BUFFERS, &r->identity_info));
@@ -414,6 +424,7 @@ static enum ndr_err_code ndr_push_netr_ChallengeResponse(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -445,6 +456,7 @@ static enum ndr_err_code ndr_pull_netr_ChallengeResponse(struct ndr_pull *ndr, i
                        } else {
                                r->data = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -502,6 +514,7 @@ static enum ndr_err_code ndr_push_netr_NetworkInfo(struct ndr_push *ndr, int ndr
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->challenge, 8));
                        NDR_CHECK(ndr_push_netr_ChallengeResponse(ndr, NDR_SCALARS, &r->nt));
                        NDR_CHECK(ndr_push_netr_ChallengeResponse(ndr, NDR_SCALARS, &r->lm));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_push_netr_IdentityInfo(ndr, NDR_BUFFERS, &r->identity_info));
@@ -524,6 +537,7 @@ static enum ndr_err_code ndr_pull_netr_NetworkInfo(struct ndr_pull *ndr, int ndr
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->challenge, 8));
                        NDR_CHECK(ndr_pull_netr_ChallengeResponse(ndr, NDR_SCALARS, &r->nt));
                        NDR_CHECK(ndr_pull_netr_ChallengeResponse(ndr, NDR_SCALARS, &r->lm));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_pull_netr_IdentityInfo(ndr, NDR_BUFFERS, &r->identity_info));
@@ -562,6 +576,7 @@ static enum ndr_err_code ndr_push_netr_GenericInfo(struct ndr_push *ndr, int ndr
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->package_name));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_push_netr_IdentityInfo(ndr, NDR_BUFFERS, &r->identity_info));
@@ -594,6 +609,7 @@ static enum ndr_err_code ndr_pull_netr_GenericInfo(struct ndr_pull *ndr, int ndr
                        } else {
                                r->data = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_pull_netr_IdentityInfo(ndr, NDR_BUFFERS, &r->identity_info));
@@ -638,14 +654,14 @@ _PUBLIC_ void ndr_print_netr_GenericInfo(struct ndr_print *ndr, const char *name
 
 static enum ndr_err_code ndr_push_netr_LogonInfoClass(struct ndr_push *ndr, int ndr_flags, enum netr_LogonInfoClass r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_netr_LogonInfoClass(struct ndr_pull *ndr, int ndr_flags, enum netr_LogonInfoClass *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -671,6 +687,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_LogonLevel(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_netr_LogonInfoClass(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case NetlogonInteractiveInformation: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
@@ -765,10 +782,11 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_LogonLevel(struct ndr_pull *ndr, int nd
        TALLOC_CTX *_mem_save_generic_0;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case NetlogonInteractiveInformation: {
                                uint32_t _ptr_password;
@@ -998,6 +1016,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_UserSessionKey(struct ndr_push *ndr, in
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->key, 16));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1014,6 +1033,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_UserSessionKey(struct ndr_pull *ndr, in
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->key, 16));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1043,6 +1063,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_LMSessionKey(struct ndr_push *ndr, int
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->key, 8));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1059,6 +1080,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_LMSessionKey(struct ndr_pull *ndr, int
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->key, 8));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1144,6 +1166,7 @@ static enum ndr_err_code ndr_push_netr_SamBaseInfo(struct ndr_push *ndr, int ndr
                for (cntr_unknown_0 = 0; cntr_unknown_0 < 7; cntr_unknown_0++) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown[cntr_unknown_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -1201,6 +1224,7 @@ static enum ndr_err_code ndr_pull_netr_SamBaseInfo(struct ndr_pull *ndr, int ndr
                for (cntr_unknown_0 = 0; cntr_unknown_0 < 7; cntr_unknown_0++) {
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown[cntr_unknown_0]));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -1274,6 +1298,7 @@ static enum ndr_err_code ndr_push_netr_SamInfo2(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_netr_SamBaseInfo(ndr, NDR_SCALARS, &r->base));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_SamBaseInfo(ndr, NDR_BUFFERS, &r->base));
@@ -1286,6 +1311,7 @@ static enum ndr_err_code ndr_pull_netr_SamInfo2(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_netr_SamBaseInfo(ndr, NDR_SCALARS, &r->base));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_SamBaseInfo(ndr, NDR_BUFFERS, &r->base));
@@ -1307,6 +1333,7 @@ static enum ndr_err_code ndr_push_netr_SidAttr(struct ndr_push *ndr, int ndr_fla
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sid) {
@@ -1329,6 +1356,7 @@ static enum ndr_err_code ndr_pull_netr_SidAttr(struct ndr_pull *ndr, int ndr_fla
                        r->sid = NULL;
                }
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sid) {
@@ -1363,6 +1391,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_SamInfo3(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_netr_SamBaseInfo(ndr, NDR_SCALARS, &r->base));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sidcount));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_SamBaseInfo(ndr, NDR_BUFFERS, &r->base));
@@ -1395,6 +1424,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_SamInfo3(struct ndr_pull *ndr, int ndr_
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_SamBaseInfo(ndr, NDR_BUFFERS, &r->base));
@@ -1460,6 +1490,7 @@ static enum ndr_err_code ndr_push_netr_SamInfo6(struct ndr_push *ndr, int ndr_fl
                for (cntr_unknown4_0 = 0; cntr_unknown4_0 < 20; cntr_unknown4_0++) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4[cntr_unknown4_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_SamBaseInfo(ndr, NDR_BUFFERS, &r->base));
@@ -1500,6 +1531,7 @@ static enum ndr_err_code ndr_pull_netr_SamInfo6(struct ndr_pull *ndr, int ndr_fl
                for (cntr_unknown4_0 = 0; cntr_unknown4_0 < 20; cntr_unknown4_0++) {
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4[cntr_unknown4_0]));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_SamBaseInfo(ndr, NDR_BUFFERS, &r->base));
@@ -1586,6 +1618,7 @@ static enum ndr_err_code ndr_push_netr_PacInfo(struct ndr_push *ndr, int ndr_fla
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->pac) {
@@ -1641,6 +1674,7 @@ static enum ndr_err_code ndr_pull_netr_PacInfo(struct ndr_pull *ndr, int ndr_fla
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->pac) {
@@ -1725,6 +1759,7 @@ static enum ndr_err_code ndr_push_netr_GenericInfo2(struct ndr_push *ndr, int nd
                        NDR_CHECK(ndr_push_align(ndr, 5));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -1753,6 +1788,7 @@ static enum ndr_err_code ndr_pull_netr_GenericInfo2(struct ndr_pull *ndr, int nd
                        } else {
                                r->data = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->data) {
@@ -1796,6 +1832,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_Validation(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case NetlogonValidationSamInfo: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sam2));
@@ -1876,6 +1913,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_Validation(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case NetlogonValidationSamInfo: {
                                uint32_t _ptr_sam2;
@@ -2049,6 +2087,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_Credential(struct ndr_push *ndr, int nd
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 8));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2065,6 +2104,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_Credential(struct ndr_pull *ndr, int nd
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 8));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2092,6 +2132,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_Authenticator(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_netr_Credential(ndr, NDR_SCALARS, &r->cred));
                NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2104,6 +2145,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_Authenticator(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_netr_Credential(ndr, NDR_SCALARS, &r->cred));
                NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2132,6 +2174,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_DELETE_USER(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->account_name) {
@@ -2168,6 +2211,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_DELETE_USER(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->account_name) {
@@ -2219,6 +2263,7 @@ static enum ndr_err_code ndr_push_netr_USER_KEY16(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->pwd));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2233,6 +2278,7 @@ static enum ndr_err_code ndr_pull_netr_USER_KEY16(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->pwd));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2262,6 +2308,7 @@ static enum ndr_err_code ndr_push_netr_PasswordHistory(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lm_flags));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->nt_history, r->nt_length));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->lm_history, r->lm_length));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2282,6 +2329,7 @@ static enum ndr_err_code ndr_pull_netr_PasswordHistory(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->nt_history, r->nt_length));
                NDR_PULL_ALLOC_N(ndr, r->lm_history, r->lm_length);
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->lm_history, r->lm_length));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2310,6 +2358,7 @@ static enum ndr_err_code ndr_push_netr_USER_KEYS2(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_netr_USER_KEY16(ndr, NDR_SCALARS, &r->lmpassword));
                NDR_CHECK(ndr_push_netr_USER_KEY16(ndr, NDR_SCALARS, &r->ntpassword));
                NDR_CHECK(ndr_push_netr_PasswordHistory(ndr, NDR_SCALARS, &r->history));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2323,6 +2372,7 @@ static enum ndr_err_code ndr_pull_netr_USER_KEYS2(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_netr_USER_KEY16(ndr, NDR_SCALARS, &r->lmpassword));
                NDR_CHECK(ndr_pull_netr_USER_KEY16(ndr, NDR_SCALARS, &r->ntpassword));
                NDR_CHECK(ndr_pull_netr_PasswordHistory(ndr, NDR_SCALARS, &r->history));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2344,6 +2394,7 @@ static enum ndr_err_code ndr_push_netr_USER_KEY_UNION(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_netr_USER_KEYS2(ndr, NDR_SCALARS, &r->keys2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2355,6 +2406,7 @@ static enum ndr_err_code ndr_pull_netr_USER_KEY_UNION(struct ndr_pull *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_netr_USER_KEYS2(ndr, NDR_SCALARS, &r->keys2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2375,6 +2427,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_USER_KEYS(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
                NDR_CHECK(ndr_push_netr_USER_KEY_UNION(ndr, NDR_SCALARS, &r->keys));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2387,6 +2440,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_USER_KEYS(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_netr_USER_KEY_UNION(ndr, NDR_SCALARS, &r->keys));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2414,6 +2468,7 @@ static enum ndr_err_code ndr_push_netr_USER_PRIVATE_INFO(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->SensitiveData));
                        ndr->flags = _flags_save_uint8;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2448,6 +2503,7 @@ static enum ndr_err_code ndr_pull_netr_USER_PRIVATE_INFO(struct ndr_pull *ndr, i
                        }
                        ndr->flags = _flags_save_uint8;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2526,6 +2582,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_USER(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2589,6 +2646,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_USER(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2678,6 +2736,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_DOMAIN(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -2714,6 +2773,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_DOMAIN(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -2771,6 +2831,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_GROUP(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->group_name));
@@ -2802,6 +2863,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_GROUP(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->group_name));
@@ -2850,6 +2912,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_RENAME(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->OldName));
@@ -2876,6 +2939,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_RENAME(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->OldName));
@@ -2918,6 +2982,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_GROUP_MEMBER(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->rids) {
@@ -2965,6 +3030,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_GROUP_MEMBER(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->rids) {
@@ -3063,6 +3129,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_ALIAS(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->alias_name));
@@ -3091,6 +3158,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_ALIAS(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->alias_name));
@@ -3131,6 +3199,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_ALIAS_MEMBER(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_BUFFERS, &r->sids));
@@ -3147,6 +3216,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_ALIAS_MEMBER(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_BUFFERS, &r->sids));
@@ -3176,6 +3246,7 @@ static enum ndr_err_code ndr_push_netr_QUOTA_LIMITS(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximumworkingsetsize));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pagefilelimit));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timelimit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3192,6 +3263,7 @@ static enum ndr_err_code ndr_pull_netr_QUOTA_LIMITS(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximumworkingsetsize));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pagefilelimit));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timelimit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3236,6 +3308,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_POLICY(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->eventauditoptions) {
@@ -3297,6 +3370,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_POLICY(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->eventauditoptions) {
@@ -3396,6 +3470,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_TRUSTED_DOMAIN(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -3443,6 +3518,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_TRUSTED_DOMAIN(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -3514,6 +3590,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_DELETE_TRUST(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3525,6 +3602,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_DELETE_TRUST(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3561,6 +3639,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_ACCOUNT(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->privilege_attrib) {
@@ -3625,6 +3704,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_ACCOUNT(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->privilege_attrib) {
@@ -3729,6 +3809,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_DELETE_ACCOUNT(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3740,6 +3821,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_DELETE_ACCOUNT(struct ndr_pull *ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3759,6 +3841,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_DELETE_SECRET(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3770,6 +3853,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_DELETE_SECRET(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3791,6 +3875,7 @@ static enum ndr_err_code ndr_push_netr_CIPHER_VALUE(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlen));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->cipher_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->cipher_data) {
@@ -3817,6 +3902,7 @@ static enum ndr_err_code ndr_pull_netr_CIPHER_VALUE(struct ndr_pull *ndr, int nd
                } else {
                        r->cipher_data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->cipher_data) {
@@ -3874,6 +3960,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_SECRET(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown7));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_CIPHER_VALUE(ndr, NDR_BUFFERS, &r->current_cipher));
@@ -3905,6 +3992,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_SECRET(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown7));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_CIPHER_VALUE(ndr, NDR_BUFFERS, &r->current_cipher));
@@ -3941,14 +4029,14 @@ _PUBLIC_ void ndr_print_netr_DELTA_SECRET(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_netr_DeltaEnum(struct ndr_push *ndr, int ndr_flags, enum netr_DeltaEnum r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_netr_DeltaEnum(struct ndr_pull *ndr, int ndr_flags, enum netr_DeltaEnum *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -3989,6 +4077,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_UNION(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_netr_DeltaEnum(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case NETR_DELTA_DOMAIN: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
@@ -4225,10 +4314,11 @@ static enum ndr_err_code ndr_pull_netr_DELTA_UNION(struct ndr_pull *ndr, int ndr
        TALLOC_CTX *_mem_save_modified_count_0;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case NETR_DELTA_DOMAIN: {
                                uint32_t _ptr_domain;
@@ -4767,6 +4857,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_ID_UNION(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_netr_DeltaEnum(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case NETR_DELTA_DOMAIN: {
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
@@ -4970,10 +5061,11 @@ static enum ndr_err_code ndr_pull_netr_DELTA_ID_UNION(struct ndr_pull *ndr, int
        TALLOC_CTX *_mem_save_name_0;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case NETR_DELTA_DOMAIN: {
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
@@ -5379,6 +5471,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_ENUM(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_netr_DELTA_ID_UNION(ndr, NDR_SCALARS, &r->delta_id_union));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->delta_union, r->delta_type));
                NDR_CHECK(ndr_push_netr_DELTA_UNION(ndr, NDR_SCALARS, &r->delta_union));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_DELTA_ID_UNION(ndr, NDR_BUFFERS, &r->delta_id_union));
@@ -5396,6 +5489,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_ENUM(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_netr_DELTA_ID_UNION(ndr, NDR_SCALARS, &r->delta_id_union));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->delta_union, r->delta_type));
                NDR_CHECK(ndr_pull_netr_DELTA_UNION(ndr, NDR_SCALARS, &r->delta_union));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_DELTA_ID_UNION(ndr, NDR_BUFFERS, &r->delta_id_union));
@@ -5423,6 +5517,7 @@ static enum ndr_err_code ndr_push_netr_DELTA_ENUM_ARRAY(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_deltas));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->delta_enum));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->delta_enum) {
@@ -5453,6 +5548,7 @@ static enum ndr_err_code ndr_pull_netr_DELTA_ENUM_ARRAY(struct ndr_pull *ndr, in
                } else {
                        r->delta_enum = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->delta_enum) {
@@ -5512,6 +5608,7 @@ static enum ndr_err_code ndr_push_netr_UAS_INFO_0(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->computer_name, 16));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timecreated));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_number));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -5530,6 +5627,7 @@ static enum ndr_err_code ndr_pull_netr_UAS_INFO_0(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->computer_name, 16));
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timecreated));
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_number));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -5563,6 +5661,7 @@ static enum ndr_err_code ndr_push_netr_AccountBuffer(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5579,6 +5678,7 @@ static enum ndr_err_code ndr_pull_netr_AccountBuffer(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->blob));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5628,6 +5728,7 @@ static enum ndr_err_code ndr_push_netr_NETLOGON_INFO_1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_netr_InfoFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->pdc_connection_status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5640,6 +5741,7 @@ static enum ndr_err_code ndr_pull_netr_NETLOGON_INFO_1(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_netr_InfoFlags(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->pdc_connection_status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5663,6 +5765,7 @@ static enum ndr_err_code ndr_push_netr_NETLOGON_INFO_2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->pdc_connection_status));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->trusted_dc_name));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->tc_connection_status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->trusted_dc_name) {
@@ -5690,6 +5793,7 @@ static enum ndr_err_code ndr_pull_netr_NETLOGON_INFO_2(struct ndr_pull *ndr, int
                        r->trusted_dc_name = NULL;
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->tc_connection_status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->trusted_dc_name) {
@@ -5735,6 +5839,7 @@ static enum ndr_err_code ndr_push_netr_NETLOGON_INFO_3(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5752,6 +5857,7 @@ static enum ndr_err_code ndr_pull_netr_NETLOGON_INFO_3(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5778,6 +5884,7 @@ static enum ndr_err_code ndr_push_netr_NETLOGON_INFO_4(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->trusted_dc_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->trusted_domain_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->trusted_dc_name) {
@@ -5816,6 +5923,7 @@ static enum ndr_err_code ndr_pull_netr_NETLOGON_INFO_4(struct ndr_pull *ndr, int
                } else {
                        r->trusted_domain_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->trusted_dc_name) {
@@ -5870,6 +5978,7 @@ static enum ndr_err_code ndr_push_netr_CONTROL_QUERY_INFORMATION(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
@@ -5941,6 +6050,7 @@ static enum ndr_err_code ndr_pull_netr_CONTROL_QUERY_INFORMATION(struct ndr_pull
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_info1;
@@ -6125,6 +6235,7 @@ static enum ndr_err_code ndr_push_netr_CONTROL_DATA_INFORMATION(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case NETLOGON_CONTROL_REDISCOVER: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
@@ -6239,6 +6350,7 @@ static enum ndr_err_code ndr_pull_netr_CONTROL_DATA_INFORMATION(struct ndr_pull
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case NETLOGON_CONTROL_REDISCOVER: {
                                uint32_t _ptr_domain;
@@ -6531,14 +6643,14 @@ _PUBLIC_ void ndr_print_netr_NegotiateFlags(struct ndr_print *ndr, const char *n
 
 static enum ndr_err_code ndr_push_SyncStateEnum(struct ndr_push *ndr, int ndr_flags, enum SyncStateEnum r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_SyncStateEnum(struct ndr_pull *ndr, int ndr_flags, enum SyncStateEnum *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -6591,6 +6703,7 @@ static enum ndr_err_code ndr_push_netr_ChangeLogObject(struct ndr_push *ndr, int
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case NETR_CHANGELOG_SID_INCLUDED: {
                                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->object_sid));
@@ -6632,6 +6745,7 @@ static enum ndr_err_code ndr_pull_netr_ChangeLogObject(struct ndr_pull *ndr, int
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case NETR_CHANGELOG_SID_INCLUDED: {
                                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->object_sid));
@@ -6699,6 +6813,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_ChangeLogEntry(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_netr_DeltaEnum8Bit(ndr, NDR_SCALARS, r->delta_type));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, r->flags & (NETR_CHANGELOG_SID_INCLUDED | NETR_CHANGELOG_NAME_INCLUDED)));
                NDR_CHECK(ndr_push_netr_ChangeLogObject(ndr, NDR_SCALARS, &r->object));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_ChangeLogObject(ndr, NDR_BUFFERS, &r->object));
@@ -6718,6 +6833,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_ChangeLogEntry(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_netr_DeltaEnum8Bit(ndr, NDR_SCALARS, &r->delta_type));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, r->flags & (NETR_CHANGELOG_SID_INCLUDED | NETR_CHANGELOG_NAME_INCLUDED)));
                NDR_CHECK(ndr_pull_netr_ChangeLogObject(ndr, NDR_SCALARS, &r->object));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_ChangeLogObject(ndr, NDR_BUFFERS, &r->object));
@@ -6751,6 +6867,7 @@ static enum ndr_err_code ndr_push_netr_Blob(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -6774,6 +6891,7 @@ static enum ndr_err_code ndr_pull_netr_Blob(struct ndr_pull *ndr, int ndr_flags,
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -6903,7 +7021,7 @@ _PUBLIC_ void ndr_print_netr_DsR_DcFlags(struct ndr_print *ndr, const char *name
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_SERVER_FULL_SECRET_DOMAIN_6", DS_SERVER_FULL_SECRET_DOMAIN_6, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_DNS_CONTROLLER", DS_DNS_CONTROLLER, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_DNS_DOMAIN", DS_DNS_DOMAIN, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_DNS_FOREST", DS_DNS_FOREST, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_DNS_FOREST_ROOT", DS_DNS_FOREST_ROOT, r);
        ndr->depth--;
 }
 
@@ -6920,6 +7038,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netr_DsRGetDCNameInfo(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_netr_DsR_DcFlags(ndr, NDR_SCALARS, r->dc_flags));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dc_site_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_site_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dc_unc) {
@@ -7017,6 +7136,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netr_DsRGetDCNameInfo(struct ndr_pull *ndr,
                } else {
                        r->client_site_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dc_unc) {
@@ -7146,6 +7266,7 @@ static enum ndr_err_code ndr_push_netr_Capabilities(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_netr_NegotiateFlags(ndr, NDR_SCALARS, r->server_capabilities));
@@ -7178,6 +7299,7 @@ static enum ndr_err_code ndr_pull_netr_Capabilities(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_netr_NegotiateFlags(ndr, NDR_SCALARS, &r->server_capabilities));
@@ -7330,6 +7452,7 @@ static enum ndr_err_code ndr_push_netr_LsaPolicyInformation(struct ndr_push *ndr
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->policy_size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->policy));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->policy) {
@@ -7353,6 +7476,7 @@ static enum ndr_err_code ndr_pull_netr_LsaPolicyInformation(struct ndr_pull *ndr
                } else {
                        r->policy = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->policy) {
@@ -7409,6 +7533,7 @@ static enum ndr_err_code ndr_push_netr_OsVersionInfoEx(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_netr_SuiteMask(ndr, NDR_SCALARS, r->SuiteMask));
                NDR_CHECK(ndr_push_netr_ProductType(ndr, NDR_SCALARS, r->ProductType));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->Reserved));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7440,6 +7565,7 @@ static enum ndr_err_code ndr_pull_netr_OsVersionInfoEx(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_netr_SuiteMask(ndr, NDR_SCALARS, &r->SuiteMask));
                NDR_CHECK(ndr_pull_netr_ProductType(ndr, NDR_SCALARS, &r->ProductType));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->Reserved));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7472,6 +7598,7 @@ static enum ndr_err_code ndr_push_netr_OsVersion(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 142));
                NDR_CHECK(ndr_push_netr_OsVersionInfoEx(ndr, NDR_SCALARS, &r->os));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7486,6 +7613,7 @@ static enum ndr_err_code ndr_pull_netr_OsVersion(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_netr_OsVersionInfoEx(ndr, NDR_SCALARS, &r->os));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7510,6 +7638,7 @@ static enum ndr_err_code ndr_push_netr_OsVersionContainer(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->os == NULL?0:284));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->os == NULL?0:284));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->os));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->os) {
@@ -7533,6 +7662,7 @@ static enum ndr_err_code ndr_pull_netr_OsVersionContainer(struct ndr_pull *ndr,
                } else {
                        r->os = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->os) {
@@ -7579,6 +7709,7 @@ static enum ndr_err_code ndr_push_netr_WorkstationInformation(struct ndr_push *n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_LsaPolicyInformation(ndr, NDR_BUFFERS, &r->lsa_policy));
@@ -7687,6 +7818,7 @@ static enum ndr_err_code ndr_pull_netr_WorkstationInformation(struct ndr_pull *n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_LsaPolicyInformation(ndr, NDR_BUFFERS, &r->lsa_policy));
@@ -7827,6 +7959,7 @@ static enum ndr_err_code ndr_push_netr_WorkstationInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->workstation_info));
@@ -7874,6 +8007,7 @@ static enum ndr_err_code ndr_pull_netr_WorkstationInfo(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_workstation_info;
@@ -7966,6 +8100,7 @@ static enum ndr_err_code ndr_push_netr_trust_extension(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->parent_index));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7983,6 +8118,7 @@ static enum ndr_err_code ndr_pull_netr_trust_extension(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->parent_index));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8010,6 +8146,7 @@ static enum ndr_err_code ndr_push_netr_trust_extension_container(struct ndr_push
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -8033,6 +8170,7 @@ static enum ndr_err_code ndr_pull_netr_trust_extension_container(struct ndr_pull
                } else {
                        r->info = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -8077,6 +8215,7 @@ static enum ndr_err_code ndr_push_netr_OneDomainInfo(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domainname));
@@ -8117,6 +8256,7 @@ static enum ndr_err_code ndr_pull_netr_OneDomainInfo(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domainname));
@@ -8204,6 +8344,7 @@ static enum ndr_err_code ndr_push_netr_DomainInformation(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_netr_SupportedEncTypes(ndr, NDR_SCALARS, r->supported_enc_types));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy_long4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_netr_OneDomainInfo(ndr, NDR_BUFFERS, &r->primary_domain));
@@ -8250,6 +8391,7 @@ static enum ndr_err_code ndr_pull_netr_DomainInformation(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_netr_SupportedEncTypes(ndr, NDR_SCALARS, &r->supported_enc_types));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long3));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy_long4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_netr_OneDomainInfo(ndr, NDR_BUFFERS, &r->primary_domain));
@@ -8320,6 +8462,7 @@ static enum ndr_err_code ndr_push_netr_DomainInfo(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_info));
@@ -8367,6 +8510,7 @@ static enum ndr_err_code ndr_pull_netr_DomainInfo(struct ndr_pull *ndr, int ndr_
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_domain_info;
@@ -8457,6 +8601,7 @@ static enum ndr_err_code ndr_push_netr_CryptPassword(struct ndr_push *ndr, int n
                        NDR_CHECK(ndr_push_align(ndr, 4));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 512));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -8474,6 +8619,7 @@ static enum ndr_err_code ndr_pull_netr_CryptPassword(struct ndr_pull *ndr, int n
                        NDR_CHECK(ndr_pull_align(ndr, 4));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 512));
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -8503,6 +8649,7 @@ static enum ndr_err_code ndr_push_netr_DsRAddressToSitenamesWCtr(struct ndr_push
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sitename));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sitename) {
@@ -8533,6 +8680,7 @@ static enum ndr_err_code ndr_pull_netr_DsRAddressToSitenamesWCtr(struct ndr_pull
                } else {
                        r->sitename = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sitename) {
@@ -8588,6 +8736,7 @@ static enum ndr_err_code ndr_push_netr_DsRAddress(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->buffer) {
@@ -8611,6 +8760,7 @@ static enum ndr_err_code ndr_pull_netr_DsRAddress(struct ndr_pull *ndr, int ndr_
                        r->buffer = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->buffer) {
@@ -8709,6 +8859,7 @@ static enum ndr_err_code ndr_push_netr_DomainTrust(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_netr_TrustAttributes(ndr, NDR_SCALARS, r->trust_attributes));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -8763,6 +8914,7 @@ static enum ndr_err_code ndr_pull_netr_DomainTrust(struct ndr_pull *ndr, int ndr
                        r->sid = NULL;
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -8836,6 +8988,7 @@ static enum ndr_err_code ndr_push_netr_DomainTrustList(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -8866,6 +9019,7 @@ static enum ndr_err_code ndr_pull_netr_DomainTrustList(struct ndr_pull *ndr, int
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -8924,6 +9078,7 @@ static enum ndr_err_code ndr_push_netr_DsRAddressToSitenamesExWCtr(struct ndr_pu
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sitename));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->subnetname));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sitename) {
@@ -8973,6 +9128,7 @@ static enum ndr_err_code ndr_pull_netr_DsRAddressToSitenamesExWCtr(struct ndr_pu
                } else {
                        r->subnetname = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sitename) {
@@ -9064,6 +9220,7 @@ static enum ndr_err_code ndr_push_DcSitesCtr(struct ndr_push *ndr, int ndr_flags
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sites));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sites));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sites) {
@@ -9094,6 +9251,7 @@ static enum ndr_err_code ndr_pull_DcSitesCtr(struct ndr_pull *ndr, int ndr_flags
                } else {
                        r->sites = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sites) {
@@ -9153,6 +9311,7 @@ static enum ndr_err_code ndr_push_netr_TrustInfo(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entry_count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -9200,6 +9359,7 @@ static enum ndr_err_code ndr_pull_netr_TrustInfo(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {

diff --git a/librpc/gen_ndr/ndr_ntlmssp.c b/librpc/gen_ndr/ndr_ntlmssp.c
index 0221d440c80bf7e7297747acf1259412d854e2f1..b863826fbd2c496228ff5524630506df0fcfa077 100644 (file)
--- a/librpc/gen_ndr/ndr_ntlmssp.c
+++ b/librpc/gen_ndr/ndr_ntlmssp.c
@@ -161,6 +161,7 @@ static enum ndr_err_code ndr_push_VERSION(struct ndr_push *ndr, int ndr_flags, c
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ProductBuild));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Reserved, 3));
                NDR_CHECK(ndr_push_ntlmssp_NTLMRevisionCurrent(ndr, NDR_SCALARS, r->NTLMRevisionCurrent));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -176,6 +177,7 @@ static enum ndr_err_code ndr_pull_VERSION(struct ndr_pull *ndr, int ndr_flags, s
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ProductBuild));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Reserved, 3));
                NDR_CHECK(ndr_pull_ntlmssp_NTLMRevisionCurrent(ndr, NDR_SCALARS, &r->NTLMRevisionCurrent));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -198,6 +200,7 @@ static enum ndr_err_code ndr_push_ntlmssp_Version(struct ndr_push *ndr, int ndr_
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 2));
                switch (level) {
                        case NTLMSSP_NEGOTIATE_VERSION: {
                                NDR_CHECK(ndr_push_VERSION(ndr, NDR_SCALARS, &r->version));
@@ -227,6 +230,7 @@ static enum ndr_err_code ndr_pull_ntlmssp_Version(struct ndr_pull *ndr, int ndr_
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 2));
                switch (level) {
                        case NTLMSSP_NEGOTIATE_VERSION: {
                                NDR_CHECK(ndr_pull_VERSION(ndr, NDR_SCALARS, &r->version));
@@ -275,6 +279,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NEGOTIATE_MESSAGE(struct ndr_push *ndr, int
                }
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
                NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -351,6 +356,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NEGOTIATE_MESSAGE(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
                NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -428,14 +434,14 @@ _PUBLIC_ void ndr_print_NEGOTIATE_MESSAGE(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_ntlmssp_AvId(struct ndr_push *ndr, int ndr_flags, enum ntlmssp_AvId r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_ntlmssp_AvId(struct ndr_pull *ndr, int ndr_flags, enum ntlmssp_AvId *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -469,6 +475,7 @@ static enum ndr_err_code ndr_push_Restriction_Encoding(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->IntegrityLevel));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SubjectIntegrityLevel));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->MachineId, 32));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -484,6 +491,7 @@ static enum ndr_err_code ndr_pull_Restriction_Encoding(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->IntegrityLevel));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SubjectIntegrityLevel));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->MachineId, 32));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -532,6 +540,7 @@ static enum ndr_err_code ndr_push_ntlmssp_AvValue(struct ndr_push *ndr, int ndr_
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
                if (ndr_flags & NDR_SCALARS) {
                        int level = ndr_push_get_switch_value(ndr, r);
+                       NDR_CHECK(ndr_push_union_align(ndr, 4));
                        switch (level) {
                                case MsvAvEOL: {
                                break; }
@@ -671,6 +680,7 @@ static enum ndr_err_code ndr_pull_ntlmssp_AvValue(struct ndr_pull *ndr, int ndr_
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
                level = ndr_pull_get_switch_value(ndr, r);
                if (ndr_flags & NDR_SCALARS) {
+                       NDR_CHECK(ndr_pull_union_align(ndr, 4));
                        switch (level) {
                                case MsvAvEOL: {
                                break; }
@@ -884,6 +894,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_AV_PAIR(struct ndr_push *ndr, int ndr_flags,
                                NDR_CHECK(ndr_push_ntlmssp_AvValue(_ndr_Value, NDR_SCALARS|NDR_BUFFERS, &r->Value));
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Value, 0, ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, ndr->iconv_convenience, 0)));
                        }
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -908,6 +919,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_AV_PAIR(struct ndr_pull *ndr, int ndr_flags,
                                NDR_CHECK(ndr_pull_ntlmssp_AvValue(_ndr_Value, NDR_SCALARS|NDR_BUFFERS, &r->Value));
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Value, 0, r->AvLen));
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -987,6 +999,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_CHALLENGE_MESSAGE(struct ndr_push *ndr, int
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->TargetInfo));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
                        NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        {
@@ -1060,6 +1073,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_CHALLENGE_MESSAGE(struct ndr_pull *ndr, int
                        }
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
                        NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        {
@@ -1147,6 +1161,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_LM_RESPONSE(struct ndr_push *ndr, int ndr_fl
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1163,6 +1178,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_LM_RESPONSE(struct ndr_pull *ndr, int ndr_fl
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1193,6 +1209,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_LMv2_RESPONSE(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->ChallengeFromClient, 8));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1210,6 +1227,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_LMv2_RESPONSE(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->ChallengeFromClient, 8));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1236,6 +1254,7 @@ static enum ndr_err_code ndr_push_ntlmssp_LM_RESPONSE(struct ndr_push *ndr, int
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 1));
                switch (level) {
                        case 24: {
                                NDR_CHECK(ndr_push_LM_RESPONSE(ndr, NDR_SCALARS, &r->v1));
@@ -1265,6 +1284,7 @@ static enum ndr_err_code ndr_pull_ntlmssp_LM_RESPONSE(struct ndr_pull *ndr, int
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 1));
                switch (level) {
                        case 24: {
                                NDR_CHECK(ndr_pull_LM_RESPONSE(ndr, NDR_SCALARS, &r->v1));
@@ -1312,6 +1332,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NTLM_RESPONSE(struct ndr_push *ndr, int ndr_
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1328,6 +1349,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NTLM_RESPONSE(struct ndr_pull *ndr, int ndr_
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -1374,6 +1396,7 @@ static enum ndr_err_code ndr_push_NTLMv2_CLIENT_CHALLENGE(struct ndr_push *ndr,
                                }
                                ndr->flags = _flags_save_AV_PAIR_LIST;
                        }
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        {
@@ -1412,6 +1435,7 @@ static enum ndr_err_code ndr_pull_NTLMv2_CLIENT_CHALLENGE(struct ndr_pull *ndr,
                                }
                                ndr->flags = _flags_save_AV_PAIR_LIST;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        {
@@ -1454,6 +1478,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NTLMv2_RESPONSE(struct ndr_push *ndr, int nd
                        NDR_CHECK(ndr_push_align(ndr, 4));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
                        NDR_CHECK(ndr_push_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_SCALARS, &r->Challenge));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_push_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_BUFFERS, &r->Challenge));
@@ -1472,6 +1497,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NTLMv2_RESPONSE(struct ndr_pull *ndr, int nd
                        NDR_CHECK(ndr_pull_align(ndr, 4));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
                        NDR_CHECK(ndr_pull_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_SCALARS, &r->Challenge));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_pull_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_BUFFERS, &r->Challenge));
@@ -1499,6 +1525,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ntlmssp_NTLM_RESPONSE(struct ndr_push *ndr,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 0: {
                        break; }
@@ -1536,6 +1563,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ntlmssp_NTLM_RESPONSE(struct ndr_pull *ndr,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 0: {
                        break; }
@@ -1632,6 +1660,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_AUTHENTICATE_MESSAGE(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_NEGOTIATE(ndr, NDR_SCALARS, r->NegotiateFlags));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
                        NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->LmChallengeResponse) {
@@ -1805,6 +1834,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_AUTHENTICATE_MESSAGE(struct ndr_pull *ndr, i
                        NDR_CHECK(ndr_pull_NEGOTIATE(ndr, NDR_SCALARS, &r->NegotiateFlags));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
                        NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->LmChallengeResponse) {
@@ -1996,6 +2026,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NTLMSSP_MESSAGE_SIGNATURE(struct ndr_push *n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->RandomPad));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Checksum));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SeqNum));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2010,6 +2041,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NTLMSSP_MESSAGE_SIGNATURE(struct ndr_pull *n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RandomPad));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Checksum));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SeqNum));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2037,6 +2069,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NTLMSSP_MESSAGE_SIGNATURE_NTLMv2(struct ndr_
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, NTLMSSP_SIGN_VERSION));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SeqNum));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2055,6 +2088,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NTLMSSP_MESSAGE_SIGNATURE_NTLMv2(struct ndr_
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SeqNum));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }

diff --git a/librpc/gen_ndr/ndr_ntsvcs.c b/librpc/gen_ndr/ndr_ntsvcs.c
index 64917b429cd9fa73e3e694213c760bfc5c963b20..07a4a45d8f6156ce1186b5c6952ab78884408640 100644 (file)
--- a/librpc/gen_ndr/ndr_ntsvcs.c
+++ b/librpc/gen_ndr/ndr_ntsvcs.c
@@ -3,7 +3,7 @@
 #include "includes.h"
 #include "../librpc/gen_ndr/ndr_ntsvcs.h"
 
-#include "librpc/gen_ndr/ndr_winreg.h"
+#include "librpc/gen_ndr/ndr_misc.h"
 static enum ndr_err_code ndr_push_PNP_GetIdListFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -45,6 +45,7 @@ static enum ndr_err_code ndr_push_PNP_HwProfInfo(struct ndr_push *ndr, int ndr_f
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->friendly_name[cntr_friendly_name_0]));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -61,6 +62,7 @@ static enum ndr_err_code ndr_pull_PNP_HwProfInfo(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->friendly_name[cntr_friendly_name_0]));
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }

diff --git a/librpc/gen_ndr/ndr_samr.c b/librpc/gen_ndr/ndr_samr.c
index 4ee4603a4e98136df1028286e49a39a11d1c095e..f4c1a0cfcfd9170f507e051ba57a4218ff2623a9 100644 (file)
--- a/librpc/gen_ndr/ndr_samr.c
+++ b/librpc/gen_ndr/ndr_samr.c
@@ -32,33 +32,6 @@ _PUBLIC_ void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *na
        ndr_print_enum(ndr, name, "ENUM", val, r);
 }
 
-_PUBLIC_ enum ndr_err_code ndr_push_samr_RejectReason(struct ndr_push *ndr, int ndr_flags, enum samr_RejectReason r)
-{
-       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r)
-{
-       uint32_t v;
-       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
-       *r = v;
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r)
-{
-       const char *val = NULL;
-
-       switch (r) {
-               case SAMR_REJECT_OTHER: val = "SAMR_REJECT_OTHER"; break;
-               case SAMR_REJECT_TOO_SHORT: val = "SAMR_REJECT_TOO_SHORT"; break;
-               case SAMR_REJECT_IN_HISTORY: val = "SAMR_REJECT_IN_HISTORY"; break;
-               case SAMR_REJECT_COMPLEXITY: val = "SAMR_REJECT_COMPLEXITY"; break;
-       }
-       ndr_print_enum(ndr, name, "ENUM", val, r);
-}
-
 _PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -248,6 +221,7 @@ static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -261,6 +235,7 @@ static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -284,6 +259,7 @@ static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -314,6 +290,7 @@ static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_fl
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -365,14 +342,14 @@ _PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, c
 
 static enum ndr_err_code ndr_push_samr_DomainInfoClass(struct ndr_push *ndr, int ndr_flags, enum samr_DomainInfoClass r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_samr_DomainInfoClass(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainInfoClass *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -487,6 +464,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
                NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
                NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -502,6 +480,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
                NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
                NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -535,6 +514,7 @@ static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
@@ -559,6 +539,7 @@ static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
@@ -591,6 +572,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -602,6 +584,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -621,6 +604,7 @@ static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
@@ -633,6 +617,7 @@ static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
@@ -653,6 +638,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -665,6 +651,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
@@ -685,6 +672,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
@@ -697,6 +685,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
@@ -717,6 +706,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -728,6 +718,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -748,6 +739,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -760,6 +752,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -780,6 +773,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -791,6 +785,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -813,6 +808,7 @@ static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *n
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
@@ -828,6 +824,7 @@ static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *n
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
@@ -853,6 +850,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -866,6 +864,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -889,6 +888,7 @@ static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -902,6 +902,7 @@ static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -923,6 +924,7 @@ static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -1037,6 +1039,7 @@ static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -1206,6 +1209,7 @@ static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ids) {
@@ -1236,6 +1240,7 @@ static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags,
                } else {
                        r->ids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ids) {
@@ -1318,6 +1323,7 @@ static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -1334,6 +1340,7 @@ static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -1358,6 +1365,7 @@ static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1369,6 +1377,7 @@ static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1385,14 +1394,14 @@ _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const ch
 
 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -1416,6 +1425,7 @@ static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case GROUPINFOALL: {
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
@@ -1476,10 +1486,11 @@ static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_f
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case GROUPINFOALL: {
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
@@ -1573,6 +1584,7 @@ static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->rids) {
@@ -1616,6 +1628,7 @@ static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int nd
                } else {
                        r->types = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->rids) {
@@ -1701,6 +1714,7 @@ static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -1716,6 +1730,7 @@ static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
@@ -1736,14 +1751,14 @@ _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -1765,6 +1780,7 @@ static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case ALIASINFOALL: {
                                NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
@@ -1810,10 +1826,11 @@ static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_f
        uint16_t _level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
+               NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case ALIASINFOALL: {
                                NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
@@ -1877,14 +1894,14 @@ _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name,
 
 static enum ndr_err_code ndr_push_samr_UserInfoLevel(struct ndr_push *ndr, int ndr_flags, enum samr_UserInfoLevel r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_samr_UserInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_UserInfoLevel *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -1930,6 +1947,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -1949,6 +1967,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -1979,6 +1998,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
@@ -1995,6 +2015,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
@@ -2023,6 +2044,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int nd
                        NDR_CHECK(ndr_push_align(ndr, 5));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->bits) {
@@ -2053,6 +2075,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int nd
                        } else {
                                r->bits = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->bits) {
@@ -2120,6 +2143,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2156,6 +2180,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2200,6 +2225,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
@@ -2212,6 +2238,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
@@ -2249,6 +2276,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2286,6 +2314,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2332,6 +2361,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2346,6 +2376,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2368,6 +2399,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2380,6 +2412,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2400,6 +2433,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
@@ -2412,6 +2446,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
@@ -2432,6 +2467,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2443,6 +2479,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2463,6 +2500,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
@@ -2477,6 +2515,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
@@ -2499,6 +2538,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
@@ -2511,6 +2551,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
@@ -2531,6 +2572,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
@@ -2543,6 +2585,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
@@ -2563,6 +2606,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
@@ -2575,6 +2619,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
@@ -2595,6 +2640,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
@@ -2607,6 +2653,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
@@ -2627,6 +2674,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2638,6 +2686,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2657,6 +2706,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2668,6 +2718,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2690,6 +2741,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2706,6 +2758,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -2736,6 +2789,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2751,6 +2805,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2774,6 +2829,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
@@ -2786,6 +2842,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
@@ -2890,6 +2947,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -2959,6 +3017,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -3044,6 +3103,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -3060,6 +3120,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -3087,6 +3148,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
@@ -3100,6 +3162,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
@@ -3122,6 +3185,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3134,6 +3198,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3157,6 +3222,7 @@ static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -3173,6 +3239,7 @@ static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -3200,6 +3267,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
@@ -3213,6 +3281,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
@@ -3235,6 +3304,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3247,6 +3317,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3267,6 +3338,7 @@ static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -3470,6 +3542,7 @@ static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_fl
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -3771,6 +3844,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3783,6 +3857,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3805,6 +3880,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->rids) {
@@ -3832,6 +3908,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *
                } else {
                        r->rids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->rids) {
@@ -3888,6 +3965,7 @@ static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -3907,6 +3985,7 @@ static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -3936,6 +4015,7 @@ static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -3966,6 +4046,7 @@ static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4024,6 +4105,7 @@ static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -4041,6 +4123,7 @@ static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -4068,6 +4151,7 @@ static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4098,6 +4182,7 @@ static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int nd
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4156,6 +4241,7 @@ static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -4173,6 +4259,7 @@ static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
@@ -4200,6 +4287,7 @@ static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4230,6 +4318,7 @@ static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr,
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4285,6 +4374,7 @@ static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
                NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
@@ -4298,6 +4388,7 @@ static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
                NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
@@ -4321,6 +4412,7 @@ static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4351,6 +4443,7 @@ static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int n
                } else {
                        r->entries = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->entries) {
@@ -4405,6 +4498,7 @@ static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
@@ -4470,6 +4564,7 @@ static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_fl
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
@@ -4561,6 +4656,7 @@ static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flag
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
                NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4573,6 +4669,7 @@ static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flag
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
                NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4614,39 +4711,100 @@ _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *n
        ndr_print_enum(ndr, name, "ENUM", val, r);
 }
 
-static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
+_PUBLIC_ enum ndr_err_code ndr_push_samPwdChangeReason(struct ndr_push *ndr, int ndr_flags, enum samPwdChangeReason r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_samPwdChangeReason(struct ndr_pull *ndr, int ndr_flags, enum samPwdChangeReason *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_samPwdChangeReason(struct ndr_print *ndr, const char *name, enum samPwdChangeReason r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SAM_PWD_CHANGE_NO_ERROR: val = "SAM_PWD_CHANGE_NO_ERROR"; break;
+               case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT: val = "SAM_PWD_CHANGE_PASSWORD_TOO_SHORT"; break;
+               case SAM_PWD_CHANGE_PWD_IN_HISTORY: val = "SAM_PWD_CHANGE_PWD_IN_HISTORY"; break;
+               case SAM_PWD_CHANGE_USERNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_USERNAME_IN_PASSWORD"; break;
+               case SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD"; break;
+               case SAM_PWD_CHANGE_NOT_COMPLEX: val = "SAM_PWD_CHANGE_NOT_COMPLEX"; break;
+               case SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT: val = "SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT"; break;
+               case SAM_PWD_CHANGE_FAILED_BY_FILTER: val = "SAM_PWD_CHANGE_FAILED_BY_FILTER"; break;
+               case SAM_PWD_CHANGE_PASSWORD_TOO_LONG: val = "SAM_PWD_CHANGE_PASSWORD_TOO_LONG"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+static enum ndr_err_code ndr_push_userPwdChangeFailureInformation(struct ndr_push *ndr, int ndr_flags, const struct userPwdChangeFailureInformation *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
-               NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_samPwdChangeReason(ndr, NDR_SCALARS, r->extendedFailureReason));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->filterModuleName));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
+               if (r->filterModuleName) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->filterModuleName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->filterModuleName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->filterModuleName, ndr_charset_length(r->filterModuleName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+               }
        }
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
+static enum ndr_err_code ndr_pull_userPwdChangeFailureInformation(struct ndr_pull *ndr, int ndr_flags, struct userPwdChangeFailureInformation *r)
 {
+       uint32_t _ptr_filterModuleName;
+       TALLOC_CTX *_mem_save_filterModuleName_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
-               NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_samPwdChangeReason(ndr, NDR_SCALARS, &r->extendedFailureReason));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filterModuleName));
+               if (_ptr_filterModuleName) {
+                       NDR_PULL_ALLOC(ndr, r->filterModuleName);
+               } else {
+                       r->filterModuleName = NULL;
+               }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
+               if (r->filterModuleName) {
+                       _mem_save_filterModuleName_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->filterModuleName, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->filterModuleName));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->filterModuleName));
+                       if (ndr_get_array_length(ndr, &r->filterModuleName) > ndr_get_array_size(ndr, &r->filterModuleName)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->filterModuleName), ndr_get_array_length(ndr, &r->filterModuleName));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->filterModuleName), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->filterModuleName, ndr_get_array_length(ndr, &r->filterModuleName), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filterModuleName_0, 0);
+               }
        }
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
+_PUBLIC_ void ndr_print_userPwdChangeFailureInformation(struct ndr_print *ndr, const char *name, const struct userPwdChangeFailureInformation *r)
 {
-       ndr_print_struct(ndr, name, "samr_ChangeReject");
+       ndr_print_struct(ndr, name, "userPwdChangeFailureInformation");
        ndr->depth++;
-       ndr_print_samr_RejectReason(ndr, "reason", r->reason);
-       ndr_print_uint32(ndr, "unknown1", r->unknown1);
-       ndr_print_uint32(ndr, "unknown2", r->unknown2);
+       ndr_print_samPwdChangeReason(ndr, "extendedFailureReason", r->extendedFailureReason);
+       ndr_print_ptr(ndr, "filterModuleName", r->filterModuleName);
+       ndr->depth++;
+       if (r->filterModuleName) {
+               ndr_print_string(ndr, "filterModuleName", r->filterModuleName);
+       }
+       ndr->depth--;
        ndr->depth--;
 }
 
@@ -4656,6 +4814,7 @@ static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4668,6 +4827,7 @@ static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4688,6 +4848,7 @@ static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -4720,6 +4881,7 @@ static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -4785,14 +4947,14 @@ _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const
 
 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -4811,14 +4973,14 @@ _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const
 
 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -4849,6 +5011,7 @@ static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -4872,6 +5035,7 @@ static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -4915,6 +5079,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->pwd_history) {
@@ -4950,6 +5115,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr
                } else {
                        r->pwd_history = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->pwd_history) {
@@ -5010,6 +5176,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *n
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5023,6 +5190,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *n
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5044,6 +5212,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
@@ -5093,6 +5262,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
@@ -5164,6 +5334,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5184,6 +5355,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5216,6 +5388,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5235,6 +5408,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5263,6 +5437,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5276,6 +5451,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
@@ -5297,6 +5473,7 @@ static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
@@ -5346,6 +5523,7 @@ static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
@@ -11660,7 +11838,7 @@ static enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr,
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
                if (*r->out.reject) {
-                       NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
+                       NDR_CHECK(ndr_push_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));
                }
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
        }
@@ -11809,7 +11987,7 @@ static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr,
                if (*r->out.reject) {
                        _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
-                       NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
+                       NDR_CHECK(ndr_pull_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
@@ -11888,7 +12066,7 @@ _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const ch
                ndr_print_ptr(ndr, "reject", *r->out.reject);
                ndr->depth++;
                if (*r->out.reject) {
-                       ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
+                       ndr_print_userPwdChangeFailureInformation(ndr, "reject", *r->out.reject);
                }
                ndr->depth--;
                ndr->depth--;

diff --git a/librpc/gen_ndr/ndr_samr.h b/librpc/gen_ndr/ndr_samr.h
index a341f69af07c701be9e135a38b5316ca827d3ead..9ece0ed5ca2bbe02e64fbc9b874d885379172f58 100644 (file)
--- a/librpc/gen_ndr/ndr_samr.h
+++ b/librpc/gen_ndr/ndr_samr.h
@@ -151,9 +151,6 @@ extern const struct ndr_interface_table ndr_table_samr;
 enum ndr_err_code ndr_push_netr_SamDatabaseID(struct ndr_push *ndr, int ndr_flags, enum netr_SamDatabaseID r);
 enum ndr_err_code ndr_pull_netr_SamDatabaseID(struct ndr_pull *ndr, int ndr_flags, enum netr_SamDatabaseID *r);
 void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *name, enum netr_SamDatabaseID r);
-enum ndr_err_code ndr_push_samr_RejectReason(struct ndr_push *ndr, int ndr_flags, enum samr_RejectReason r);
-enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r);
-void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r);
 enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r);
 enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r);
 void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r);
@@ -248,7 +245,10 @@ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const
 void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r);
 void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r);
 void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r);
-void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r);
+enum ndr_err_code ndr_push_samPwdChangeReason(struct ndr_push *ndr, int ndr_flags, enum samPwdChangeReason r);
+enum ndr_err_code ndr_pull_samPwdChangeReason(struct ndr_pull *ndr, int ndr_flags, enum samPwdChangeReason *r);
+void ndr_print_samPwdChangeReason(struct ndr_print *ndr, const char *name, enum samPwdChangeReason r);
+void ndr_print_userPwdChangeFailureInformation(struct ndr_print *ndr, const char *name, const struct userPwdChangeFailureInformation *r);
 void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r);
 void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r);
 void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r);

diff --git a/librpc/gen_ndr/ndr_schannel.c b/librpc/gen_ndr/ndr_schannel.c
index 8fa87f4d2d9fe48ff79a142e98daac726f356d95..9a2396f04ec230214cf13c7dd6922ab6862a367b 100644 (file)
--- a/librpc/gen_ndr/ndr_schannel.c
+++ b/librpc/gen_ndr/ndr_schannel.c
@@ -28,6 +28,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_netlogon_creds_CredentialState(struct ndr_pu
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->sid) {
@@ -75,6 +76,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_netlogon_creds_CredentialState(struct ndr_pu
                        } else {
                                r->sid = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->sid) {
@@ -171,6 +173,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_MESSAGE_BUFFER(struct ndr_push *ndr,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case NL_FLAG_OEM_NETBIOS_DOMAIN_NAME: {
                                {
@@ -238,6 +241,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE_BUFFER(struct ndr_pull *ndr,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case NL_FLAG_OEM_NETBIOS_DOMAIN_NAME: {
                                {
@@ -303,6 +307,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_MESSAGE_BUFFER_REPLY(struct ndr_push
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case NL_NEGOTIATE_RESPONSE: {
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy));
@@ -332,6 +337,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE_BUFFER_REPLY(struct ndr_pull
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case NL_NEGOTIATE_RESPONSE: {
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy));
@@ -376,6 +382,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_MESSAGE(struct ndr_push *ndr, int nd
                        NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_netbios_computer));
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Buffer, r->MessageType & NL_NEGOTIATE_RESPONSE));
                        NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, NDR_SCALARS, &r->Buffer));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->oem_netbios_domain));
@@ -411,6 +418,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE(struct ndr_pull *ndr, int nd
                        NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_netbios_computer));
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Buffer, r->MessageType & NL_NEGOTIATE_RESPONSE));
                        NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, NDR_SCALARS, &r->Buffer));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->oem_netbios_domain));
@@ -453,14 +461,14 @@ _PUBLIC_ void ndr_print_NL_AUTH_MESSAGE(struct ndr_print *ndr, const char *name,
 
 static enum ndr_err_code ndr_push_NL_SIGNATURE_ALGORITHM(struct ndr_push *ndr, int ndr_flags, enum NL_SIGNATURE_ALGORITHM r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_NL_SIGNATURE_ALGORITHM(struct ndr_pull *ndr, int ndr_flags, enum NL_SIGNATURE_ALGORITHM *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -478,14 +486,14 @@ _PUBLIC_ void ndr_print_NL_SIGNATURE_ALGORITHM(struct ndr_print *ndr, const char
 
 static enum ndr_err_code ndr_push_NL_SEAL_ALGORITHM(struct ndr_push *ndr, int ndr_flags, enum NL_SEAL_ALGORITHM r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_NL_SEAL_ALGORITHM(struct ndr_pull *ndr, int ndr_flags, enum NL_SEAL_ALGORITHM *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -508,7 +516,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_SIGNATURE(struct ndr_push *ndr, int
                uint32_t _flags_save_STRUCT = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
-                       NDR_CHECK(ndr_push_align(ndr, 2));
+                       NDR_CHECK(ndr_push_align(ndr, 3));
                        NDR_CHECK(ndr_push_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, NL_SIGN_HMAC_MD5));
                        NDR_CHECK(ndr_push_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, r->SealAlgorithm));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Pad));
@@ -516,6 +524,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_SIGNATURE(struct ndr_push *ndr, int
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 3));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -530,7 +539,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_SIGNATURE(struct ndr_pull *ndr, int
                uint32_t _flags_save_STRUCT = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
-                       NDR_CHECK(ndr_pull_align(ndr, 2));
+                       NDR_CHECK(ndr_pull_align(ndr, 3));
                        NDR_CHECK(ndr_pull_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, &r->SignatureAlgorithm));
                        NDR_CHECK(ndr_pull_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, &r->SealAlgorithm));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Pad));
@@ -538,6 +547,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_SIGNATURE(struct ndr_pull *ndr, int
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -571,7 +581,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_SHA2_SIGNATURE(struct ndr_push *ndr,
                uint32_t _flags_save_STRUCT = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
-                       NDR_CHECK(ndr_push_align(ndr, 2));
+                       NDR_CHECK(ndr_push_align(ndr, 3));
                        NDR_CHECK(ndr_push_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, NL_SIGN_HMAC_SHA256));
                        NDR_CHECK(ndr_push_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, r->SealAlgorithm));
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Pad));
@@ -579,6 +589,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_SHA2_SIGNATURE(struct ndr_push *ndr,
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Checksum, 32));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 3));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -593,7 +604,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_SHA2_SIGNATURE(struct ndr_pull *ndr,
                uint32_t _flags_save_STRUCT = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
-                       NDR_CHECK(ndr_pull_align(ndr, 2));
+                       NDR_CHECK(ndr_pull_align(ndr, 3));
                        NDR_CHECK(ndr_pull_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, &r->SignatureAlgorithm));
                        NDR_CHECK(ndr_pull_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, &r->SealAlgorithm));
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Pad));
@@ -601,6 +612,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_SHA2_SIGNATURE(struct ndr_pull *ndr,
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Checksum, 32));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }

diff --git a/librpc/gen_ndr/ndr_security.c b/librpc/gen_ndr/ndr_security.c
index f6aac8ad0199a9edb3f46b53a778a6b92f9baedb..5453d0c12b3960bfedcd057132b1d2273411e08e 100644 (file)
--- a/librpc/gen_ndr/ndr_security.c
+++ b/librpc/gen_ndr/ndr_security.c
@@ -92,6 +92,7 @@ static enum ndr_err_code ndr_push_security_ace_object_type(struct ndr_push *ndr,
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case SEC_ACE_OBJECT_TYPE_PRESENT: {
                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->type));
@@ -121,6 +122,7 @@ static enum ndr_err_code ndr_pull_security_ace_object_type(struct ndr_pull *ndr,
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case SEC_ACE_OBJECT_TYPE_PRESENT: {
                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->type));
@@ -164,6 +166,7 @@ static enum ndr_err_code ndr_push_security_ace_object_inherited_type(struct ndr_
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->inherited_type));
@@ -193,6 +196,7 @@ static enum ndr_err_code ndr_pull_security_ace_object_inherited_type(struct ndr_
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->inherited_type));
@@ -241,6 +245,7 @@ static enum ndr_err_code ndr_push_security_ace_object(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
                NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
@@ -258,6 +263,7 @@ static enum ndr_err_code ndr_pull_security_ace_object(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
                NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
@@ -282,6 +288,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_ace_object_ctr(struct ndr_push *ndr
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
@@ -336,6 +343,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_security_ace_object_ctr(struct ndr_pull *ndr
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
@@ -423,6 +431,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_ace(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, r->type));
                NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->trustee));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
@@ -446,14 +455,14 @@ _PUBLIC_ void ndr_print_security_ace(struct ndr_print *ndr, const char *name, co
 
 static enum ndr_err_code ndr_push_security_acl_revision(struct ndr_push *ndr, int ndr_flags, enum security_acl_revision r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_security_acl_revision(struct ndr_pull *ndr, int ndr_flags, enum security_acl_revision *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -480,6 +489,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_acl(struct ndr_push *ndr, int ndr_f
                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
                        NDR_CHECK(ndr_push_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
@@ -508,6 +518,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_security_acl(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -615,6 +626,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->owner_sid) {
@@ -684,6 +696,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor(struct ndr_pull *ndr, in
                        } else {
                                r->dacl = NULL;
                        }
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
                }
                if (ndr_flags & NDR_BUFFERS) {
                        if (r->owner_sid) {
@@ -776,6 +789,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_sec_desc_buf(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_security_descriptor(r->sd, ndr->iconv_convenience, ndr->flags)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sd) {
@@ -806,6 +820,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_sec_desc_buf(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->sd = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sd) {
@@ -851,6 +866,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_token(struct ndr_push *ndr, int ndr
                }
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->privilege_mask));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_dacl));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user_sid) {
@@ -921,6 +937,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_security_token(struct ndr_pull *ndr, int ndr
                if (r->sids) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user_sid) {

diff --git a/librpc/gen_ndr/ndr_spoolss.c b/librpc/gen_ndr/ndr_spoolss.c
index 88ff090fefd480130754b34e4ad49e44319447ad..fb452bcec381709ff133c7abc1b9ef85aa7b5def 100644 (file)
--- a/librpc/gen_ndr/ndr_spoolss.c
+++ b/librpc/gen_ndr/ndr_spoolss.c
@@ -18,6 +18,7 @@ static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_fla
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -36,6 +37,7 @@ static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_fla
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -68,6 +70,7 @@ static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->time) {
@@ -90,6 +93,7 @@ static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_
                } else {
                        r->time = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->time) {
@@ -118,14 +122,14 @@ _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name,
 
 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -347,6 +351,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -430,6 +435,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1084,6 +1090,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int
                        }
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1139,6 +1146,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int
                        }
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1292,6 +1300,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1372,6 +1381,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, i
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1534,6 +1544,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1844,6 +1855,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2148,6 +2160,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->secdesc) {
@@ -2176,6 +2189,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, i
                } else {
                        r->secdesc = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->secdesc) {
@@ -2232,6 +2246,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2289,6 +2304,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2369,6 +2385,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2428,6 +2445,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2496,6 +2514,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2507,6 +2526,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2563,6 +2583,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2597,6 +2618,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -2642,6 +2664,7 @@ static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->devmode) {
@@ -2670,6 +2693,7 @@ static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, i
                } else {
                        r->devmode = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->devmode) {
@@ -2709,6 +2733,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, in
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -2833,6 +2858,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, in
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -3013,6 +3039,7 @@ static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->devmode) {
@@ -3040,6 +3067,7 @@ static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr,
                } else {
                        r->devmode = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->devmode) {
@@ -3118,6 +3146,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -3276,6 +3305,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -3504,6 +3534,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -3784,6 +3815,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -4062,6 +4094,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4075,6 +4108,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4174,6 +4208,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -4455,6 +4490,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -4732,6 +4768,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int nd
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -4796,6 +4833,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int nd
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -4903,6 +4941,7 @@ static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printer_name) {
@@ -5007,6 +5046,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printer_name) {
@@ -5162,6 +5202,7 @@ static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printer_name) {
@@ -5328,6 +5369,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printer_name) {
@@ -5562,6 +5604,7 @@ static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printer_name) {
@@ -5729,6 +5772,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printer_name) {
@@ -5941,6 +5985,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
@@ -6012,6 +6057,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_info1;
@@ -6159,6 +6205,7 @@ static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
@@ -6173,6 +6220,7 @@ static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
@@ -6283,6 +6331,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->servername) {
@@ -6348,6 +6397,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->servername) {
@@ -6432,6 +6482,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->description) {
@@ -6485,6 +6536,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr,
                } else {
                        r->comment = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->description) {
@@ -6578,6 +6630,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->servername) {
@@ -6785,6 +6838,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->servername) {
@@ -7043,6 +7097,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7054,6 +7109,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7075,6 +7131,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printername) {
@@ -7114,6 +7171,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr,
                        r->servername = NULL;
                }
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printername) {
@@ -7173,6 +7231,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printername) {
@@ -7214,6 +7273,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->printername) {
@@ -7271,6 +7331,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7282,6 +7343,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7302,6 +7364,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
                NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->guid) {
@@ -7327,6 +7390,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr,
                        r->guid = NULL;
                }
                NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->guid) {
@@ -7364,6 +7428,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -7501,6 +7566,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -7816,6 +7882,7 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
@@ -7830,6 +7897,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
@@ -7858,6 +7926,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
                        ndr->flags = _flags_save_string_array;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7875,6 +7944,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, in
                        NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
                        ndr->flags = _flags_save_string_array;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7895,6 +7965,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -7919,6 +7990,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, i
                } else {
                        r->driver_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -7987,6 +8059,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -8068,6 +8141,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, i
                } else {
                        r->config_file = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -8187,6 +8261,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -8322,6 +8397,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, i
                } else {
                        r->dependent_files = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -8510,6 +8586,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -8657,6 +8734,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, i
                } else {
                        r->previous_names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -8886,6 +8964,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -9091,6 +9170,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, i
                } else {
                        r->provider = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -9382,6 +9462,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -9656,6 +9737,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, i
                }
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->driver_name) {
@@ -10002,6 +10084,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
@@ -10093,6 +10176,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_info1;
@@ -10293,6 +10377,7 @@ static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
@@ -10307,6 +10392,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
                NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
@@ -10334,6 +10420,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -10367,6 +10454,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, in
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -10441,6 +10529,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -10567,6 +10656,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, in
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -10750,6 +10840,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -10968,6 +11059,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, in
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -11241,6 +11333,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
                        ndr->flags = _flags_save_string_array;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -11482,6 +11575,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, in
                        }
                        ndr->flags = _flags_save_string_array;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -11749,6 +11843,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -11878,6 +11973,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -12096,6 +12192,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -12431,6 +12528,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, in
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -12870,6 +12968,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, in
                }
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -13323,6 +13422,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, in
                }
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -13786,6 +13886,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr,
                }
                NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -13821,6 +13922,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr,
                }
                NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -13948,6 +14050,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -14053,6 +14156,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -14210,6 +14314,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -14226,6 +14331,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -14250,6 +14356,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 4));
@@ -14287,6 +14394,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 4));
@@ -14349,6 +14457,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -14382,6 +14491,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -14426,6 +14536,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -14461,6 +14572,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -14515,6 +14627,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -14531,6 +14644,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -14555,6 +14669,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct n
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 4));
@@ -14592,6 +14707,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 4));
@@ -14651,6 +14767,7 @@ static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->document_name) {
@@ -14703,6 +14820,7 @@ static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, in
                } else {
                        r->datatype = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->document_name) {
@@ -14775,6 +14893,7 @@ static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
@@ -14825,6 +14944,7 @@ static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_info1;
@@ -14919,6 +15039,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -14945,6 +15066,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -14994,6 +15116,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -15025,6 +15148,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -15058,6 +15182,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, in
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case REG_NONE: {
                        break; }
@@ -15135,6 +15260,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, in
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case REG_NONE: {
                        break; }
@@ -15275,6 +15401,7 @@ static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -15287,6 +15414,7 @@ static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -15310,6 +15438,7 @@ static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -15324,6 +15453,7 @@ static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -15354,6 +15484,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int
                }
                NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -15390,6 +15521,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -15490,6 +15622,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -15598,6 +15731,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -15711,6 +15845,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int n
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -15756,6 +15891,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -15827,6 +15963,7 @@ static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
                NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->form_name) {
@@ -15854,6 +15991,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->form_name) {
@@ -15902,6 +16040,7 @@ static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->form_name) {
@@ -15974,6 +16113,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int
                        r->display_name = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->form_name) {
@@ -16070,6 +16210,7 @@ static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
@@ -16117,6 +16258,7 @@ static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_info1;
@@ -16208,6 +16350,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16241,6 +16384,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16329,6 +16473,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int
                }
                NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16410,6 +16555,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16567,6 +16713,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16602,6 +16749,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16654,6 +16802,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16688,6 +16837,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16733,6 +16883,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int n
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -16798,6 +16949,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -16894,6 +17046,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16927,6 +17080,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, i
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -16988,6 +17142,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -17067,6 +17222,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, i
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -17153,6 +17309,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, in
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -17198,6 +17355,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, in
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -17266,6 +17424,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_p
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -17299,6 +17458,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_p
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -17343,6 +17503,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_pu
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_align(ndr, 5));
@@ -17378,6 +17539,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pu
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_align(ndr, 5));
@@ -17591,6 +17753,7 @@ static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_fl
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 2));
                switch (level) {
                        case PRINTER_NOTIFY_TYPE: {
                                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
@@ -17628,6 +17791,7 @@ static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_fl
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 2));
                switch (level) {
                        case PRINTER_NOTIFY_TYPE: {
                                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
@@ -17670,6 +17834,7 @@ static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->fields) {
@@ -17702,6 +17867,7 @@ static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr,
                } else {
                        r->fields = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->fields) {
@@ -17785,6 +17951,7 @@ static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->types) {
@@ -17817,6 +17984,7 @@ static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int
                } else {
                        r->types = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->types) {
@@ -17874,6 +18042,7 @@ static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -17897,6 +18066,7 @@ static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -17960,6 +18130,7 @@ static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t cntr_integer_0;
@@ -18027,6 +18198,7 @@ static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t cntr_integer_0;
@@ -18135,6 +18307,7 @@ static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
                NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
@@ -18153,6 +18326,7 @@ static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
                NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
@@ -18186,6 +18360,7 @@ static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int n
                for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
                        NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
@@ -18215,6 +18390,7 @@ static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int n
                if (r->notifies) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -18253,6 +18429,7 @@ static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -18289,6 +18466,7 @@ static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -18377,6 +18555,7 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
                NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
                NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -18420,6 +18599,7 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
                NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
                NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -18479,6 +18659,7 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -18490,6 +18671,7 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -18518,6 +18700,7 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
                NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -18564,6 +18747,7 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
                NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -18626,6 +18810,7 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
@@ -18684,6 +18869,7 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_level1;
@@ -18800,6 +18986,7 @@ static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
                NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
@@ -18814,6 +19001,7 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
                NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
@@ -18874,6 +19062,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *n
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
@@ -18933,6 +19122,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *n
                        r->data = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
@@ -19068,6 +19258,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19093,6 +19284,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19139,6 +19331,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19163,6 +19356,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19200,6 +19394,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19216,6 +19411,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19267,6 +19463,7 @@ static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -19281,6 +19478,7 @@ static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }

diff --git a/librpc/gen_ndr/ndr_srvsvc.c b/librpc/gen_ndr/ndr_srvsvc.c
index 54eca841abe2c34480123ecda412c9db7ee7d69e..740f61082193c2d71ade58aaa4b3aa7a5a34166f 100644 (file)
--- a/librpc/gen_ndr/ndr_srvsvc.c
+++ b/librpc/gen_ndr/ndr_srvsvc.c
@@ -10,6 +10,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo0(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -34,6 +35,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo0(struct ndr_pull *ndr, i
                } else {
                        r->device = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -72,6 +74,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr0(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -102,6 +105,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr0(struct ndr_pull *ndr, in
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -159,6 +163,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo1(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -199,6 +204,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo1(struct ndr_pull *ndr, i
                        r->user = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -257,6 +263,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr1(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -287,6 +294,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr1(struct ndr_pull *ndr, in
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -341,6 +349,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -390,6 +399,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -479,6 +489,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -528,6 +539,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -619,6 +631,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfoCtr(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -633,6 +646,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfoCtr(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -655,6 +669,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo0(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -679,6 +694,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo0(struct ndr_pull *ndr,
                } else {
                        r->device = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -717,6 +733,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr0(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -747,6 +764,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr0(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -805,6 +823,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo1(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->devices));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_ahead));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -846,6 +865,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo1(struct ndr_pull *ndr,
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_ahead));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->device) {
@@ -905,6 +925,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr1(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -935,6 +956,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr1(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -989,6 +1011,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -1038,6 +1061,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo(struct ndr_pull *ndr, i
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -1127,6 +1151,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -1176,6 +1201,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -1267,6 +1293,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfoCtr(struct ndr_push *ndr
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -1281,6 +1308,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfoCtr(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -1303,6 +1331,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetConnInfo0(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1314,6 +1343,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo0(struct ndr_pull *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1335,6 +1365,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetConnCtr0(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -1362,6 +1393,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr0(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -1419,6 +1451,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetConnInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_time));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->share));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user) {
@@ -1462,6 +1495,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo1(struct ndr_pull *ndr, int
                } else {
                        r->share = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user) {
@@ -1523,6 +1557,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetConnCtr1(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -1553,6 +1588,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr1(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -1607,6 +1643,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetConnCtr(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -1656,6 +1693,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -1747,6 +1785,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetConnInfoCtr(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -1761,6 +1800,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetConnInfoCtr(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -1783,6 +1823,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileInfo2(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1794,6 +1835,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo2(struct ndr_pull *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1815,6 +1857,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileCtr2(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -1842,6 +1885,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr2(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -1897,6 +1941,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileInfo3(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_locks));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -1938,6 +1983,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo3(struct ndr_pull *ndr, int
                } else {
                        r->user = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->path) {
@@ -1997,6 +2043,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileCtr3(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2027,6 +2074,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr3(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2081,6 +2129,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileInfo(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
@@ -2130,6 +2179,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo(struct ndr_pull *ndr, int n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                uint32_t _ptr_info2;
@@ -2219,6 +2269,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileCtr(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
@@ -2268,6 +2319,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                uint32_t _ptr_ctr2;
@@ -2359,6 +2411,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetFileInfoCtr(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -2373,6 +2426,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetFileInfoCtr(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -2395,6 +2449,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessInfo0(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2419,6 +2474,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo0(struct ndr_pull *ndr, int
                } else {
                        r->client = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2457,6 +2513,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessCtr0(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2487,6 +2544,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr0(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2546,6 +2604,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2588,6 +2647,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo1(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2648,6 +2708,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessCtr1(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2678,6 +2739,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr1(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2738,6 +2800,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2794,6 +2857,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo2(struct ndr_pull *ndr, int
                } else {
                        r->client_type = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2872,6 +2936,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessCtr2(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2902,6 +2967,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr2(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -2959,6 +3025,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessInfo10(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -2999,6 +3066,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo10(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -3057,6 +3125,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessCtr10(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3087,6 +3156,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr10(struct ndr_pull *ndr, int
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3148,6 +3218,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessInfo502(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -3218,6 +3289,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo502(struct ndr_pull *ndr, in
                } else {
                        r->transport = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client) {
@@ -3314,6 +3386,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessCtr502(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3344,6 +3417,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr502(struct ndr_pull *ndr, int
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3398,6 +3472,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessCtr(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -3480,6 +3555,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -3655,6 +3731,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSessInfoCtr(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3669,6 +3746,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSessInfoCtr(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3741,6 +3819,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo0(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -3765,6 +3844,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo0(struct ndr_pull *ndr, int
                } else {
                        r->name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -3803,6 +3883,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr0(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3833,6 +3914,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr0(struct ndr_pull *ndr, int
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3889,6 +3971,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
                NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -3928,6 +4011,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1(struct ndr_pull *ndr, int
                } else {
                        r->comment = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -3985,6 +4069,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4015,6 +4100,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1(struct ndr_pull *ndr, int
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4076,6 +4162,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -4146,6 +4233,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo2(struct ndr_pull *ndr, int
                } else {
                        r->password = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -4242,6 +4330,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4272,6 +4361,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr2(struct ndr_pull *ndr, int
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4329,6 +4419,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo501(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->csc_policy));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -4369,6 +4460,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo501(struct ndr_pull *ndr, i
                        r->comment = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->csc_policy));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -4427,6 +4519,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr501(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4457,6 +4550,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr501(struct ndr_pull *ndr, in
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4519,6 +4613,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo502(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -4591,6 +4686,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo502(struct ndr_pull *ndr, i
                        r->password = NULL;
                }
                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -4689,6 +4785,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr502(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4719,6 +4816,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr502(struct ndr_pull *ndr, in
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4773,6 +4871,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1004(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -4797,6 +4896,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1004(struct ndr_pull *ndr,
                } else {
                        r->comment = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -4835,6 +4935,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1004(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4865,6 +4966,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1004(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4942,6 +5044,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1005(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_NetShareInfo1005Flags(ndr, NDR_SCALARS, r->dfs_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4953,6 +5056,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1005(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_NetShareInfo1005Flags(ndr, NDR_SCALARS, &r->dfs_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4974,6 +5078,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1005(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5001,6 +5106,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1005(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5052,6 +5158,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1006(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5063,6 +5170,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1006(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5084,6 +5192,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1006(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5111,6 +5220,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1006(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5163,6 +5273,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1007(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->alternate_directory_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->alternate_directory_name) {
@@ -5188,6 +5299,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1007(struct ndr_pull *ndr,
                } else {
                        r->alternate_directory_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->alternate_directory_name) {
@@ -5227,6 +5339,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1007(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5257,6 +5370,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1007(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5313,6 +5427,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1501(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5343,6 +5458,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1501(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5397,6 +5513,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -5534,6 +5651,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -5847,6 +5965,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareCtr(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -5984,6 +6103,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr(struct ndr_pull *ndr, int n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -6299,6 +6419,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetShareInfoCtr(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -6313,6 +6434,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetShareInfoCtr(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -6364,6 +6486,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo100(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -6389,6 +6512,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo100(struct ndr_pull *ndr, i
                } else {
                        r->server_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -6431,6 +6555,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo101(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
                NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -6473,6 +6598,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo101(struct ndr_pull *ndr, i
                } else {
                        r->comment = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -6543,6 +6669,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo102(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->licenses));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->userpath));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -6605,6 +6732,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo102(struct ndr_pull *ndr, int
                } else {
                        r->userpath = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -6717,6 +6845,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo402(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->alerts) {
@@ -6797,6 +6926,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo402(struct ndr_pull *ndr, int
                } else {
                        r->srvheuristics = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->alerts) {
@@ -6930,6 +7060,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo403(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditedevents));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditprofile));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->autopath));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->alerts) {
@@ -7026,6 +7157,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo403(struct ndr_pull *ndr, int
                } else {
                        r->autopath = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->alerts) {
@@ -7163,6 +7295,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo502(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7191,6 +7324,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo502(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7268,6 +7402,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo503(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain) {
@@ -7333,6 +7468,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo503(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain) {
@@ -7464,6 +7600,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo599(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain) {
@@ -7542,6 +7679,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo599(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain) {
@@ -7632,6 +7770,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1005(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -7656,6 +7795,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1005(struct ndr_pull *ndr, in
                } else {
                        r->comment = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->comment) {
@@ -7692,6 +7832,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1010(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7703,6 +7844,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1010(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7722,6 +7864,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1016(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7733,6 +7876,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1016(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7752,6 +7896,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1017(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7763,6 +7908,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1017(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7782,6 +7928,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1018(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7793,6 +7940,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1018(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7812,6 +7960,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1107(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7823,6 +7972,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1107(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7842,6 +7992,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1501(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopens));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7853,6 +8004,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1501(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopens));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7872,6 +8024,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1502(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessvcs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7883,6 +8036,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1502(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessvcs));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7902,6 +8056,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1503(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7913,6 +8068,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1503(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7932,6 +8088,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1506(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7943,6 +8100,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1506(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7962,6 +8120,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1509(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7973,6 +8132,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1509(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7992,6 +8152,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1510(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8003,6 +8164,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1510(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8022,6 +8184,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1511(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesscons));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8033,6 +8196,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1511(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesscons));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8052,6 +8216,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1512(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8063,6 +8228,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1512(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8082,6 +8248,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1513(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8093,6 +8260,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1513(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8112,6 +8280,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1514(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8123,6 +8292,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1514(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8142,6 +8312,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1515(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8153,6 +8324,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1515(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8172,6 +8344,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1516(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8183,6 +8356,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1516(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8202,6 +8376,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1518(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8213,6 +8388,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1518(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8232,6 +8408,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1520(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8243,6 +8420,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1520(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8262,6 +8440,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1521(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8273,6 +8452,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1521(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8292,6 +8472,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1522(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8303,6 +8484,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1522(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8322,6 +8504,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1523(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8333,6 +8516,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1523(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8352,6 +8536,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1524(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8363,6 +8548,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1524(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8382,6 +8568,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1525(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8393,6 +8580,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1525(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8412,6 +8600,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1528(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8423,6 +8612,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1528(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8442,6 +8632,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1529(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8453,6 +8644,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1529(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8472,6 +8664,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1530(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8483,6 +8676,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1530(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8502,6 +8696,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1533(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8513,6 +8708,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1533(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8532,6 +8728,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1534(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8543,6 +8740,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1534(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8562,6 +8760,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1535(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8573,6 +8772,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1535(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8592,6 +8792,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1536(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8603,6 +8804,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1536(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8622,6 +8824,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1537(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8633,6 +8836,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1537(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8652,6 +8856,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1538(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8663,6 +8868,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1538(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8682,6 +8888,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1539(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8693,6 +8900,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1539(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8712,6 +8920,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1540(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8723,6 +8932,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1540(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8742,6 +8952,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1541(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8753,6 +8964,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1541(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8772,6 +8984,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1542(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8783,6 +8996,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1542(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8802,6 +9016,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1543(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8813,6 +9028,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1543(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8832,6 +9048,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1544(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8843,6 +9060,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1544(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8862,6 +9080,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1545(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8873,6 +9092,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1545(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8892,6 +9112,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1546(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8903,6 +9124,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1546(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8922,6 +9144,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1547(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8933,6 +9156,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1547(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8952,6 +9176,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1548(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8963,6 +9188,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1548(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8982,6 +9208,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1549(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -8993,6 +9220,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1549(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9012,6 +9240,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1550(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9023,6 +9252,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1550(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9042,6 +9272,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1552(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9053,6 +9284,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1552(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9072,6 +9304,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1553(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9083,6 +9316,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1553(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9102,6 +9336,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1554(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9113,6 +9348,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1554(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9132,6 +9368,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1555(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9143,6 +9380,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1555(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9162,6 +9400,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1556(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9173,6 +9412,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1556(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9192,6 +9432,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 100: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
@@ -9868,6 +10109,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo(struct ndr_pull *ndr, int nd
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 100: {
                                uint32_t _ptr_info100;
@@ -11555,6 +11797,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo0(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->disk) + 1));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->disk, strlen(r->disk) + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11568,6 +11811,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo0(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_offset));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_length));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->disk, r->__disk_length, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11591,6 +11835,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->disks));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->disks) {
@@ -11620,6 +11865,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo(struct ndr_pull *ndr, int n
                } else {
                        r->disks = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->disks) {
@@ -11694,6 +11940,7 @@ static enum ndr_err_code ndr_push_srvsvc_Statistics(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->avresponse));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reqbufneed));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bigbufneed));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11721,6 +11968,7 @@ static enum ndr_err_code ndr_pull_srvsvc_Statistics(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->avresponse));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reqbufneed));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bigbufneed));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11760,6 +12008,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo0(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -11812,6 +12061,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo0(struct ndr_pull *ndr,
                } else {
                        r->net_addr = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -11887,6 +12137,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr0(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -11917,6 +12168,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr0(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -11976,6 +12228,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo1(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -12042,6 +12295,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo1(struct ndr_pull *ndr,
                } else {
                        r->domain = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -12135,6 +12389,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr1(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -12165,6 +12420,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr1(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -12225,6 +12481,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo2(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -12292,6 +12549,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo2(struct ndr_pull *ndr,
                        r->domain = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -12386,6 +12644,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr2(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -12416,6 +12675,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr2(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -12478,6 +12738,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo3(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -12547,6 +12808,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo3(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -12643,6 +12905,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr3(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -12673,6 +12936,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr3(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -12727,6 +12991,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -12798,6 +13063,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr(struct ndr_pull *ndr, i
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -12945,6 +13211,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportInfoCtr(struct ndr_push *nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -12959,6 +13226,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfoCtr(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -12992,6 +13260,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetRemoteTODInfo(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->weekday));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -13014,6 +13283,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTODInfo(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->weekday));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -13044,6 +13314,7 @@ static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
@@ -13101,6 +13372,7 @@ static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));

diff --git a/librpc/gen_ndr/ndr_svcctl.c b/librpc/gen_ndr/ndr_svcctl.c
index 4b190b6c9114178f4ee8161357b87677531bed2e..4a81cc683ccaeda185aef93a005d13204bb0d57c 100644 (file)
--- a/librpc/gen_ndr/ndr_svcctl.c
+++ b/librpc/gen_ndr/ndr_svcctl.c
@@ -12,6 +12,7 @@ static enum ndr_err_code ndr_push_SERVICE_LOCK_STATUS(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_locked));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->lock_owner));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_duration));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->lock_owner) {
@@ -38,6 +39,7 @@ static enum ndr_err_code ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int
                        r->lock_owner = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_duration));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->lock_owner) {
@@ -141,6 +143,7 @@ static enum ndr_err_code ndr_push_SERVICE_STATUS(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_exit_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->check_point));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wait_hint));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -158,6 +161,7 @@ static enum ndr_err_code ndr_pull_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_exit_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->check_point));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wait_hint));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -185,6 +189,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVICE_STATUS_PROCESS(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->process_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -198,6 +203,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_STATUS_PROCESS(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->process_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -231,6 +237,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSW(struct ndr_push *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -288,6 +295,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSW(struct ndr_pull *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -366,6 +374,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSA(struct ndr_push *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -423,6 +432,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSA(struct ndr_pull *ndr, i
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -711,6 +721,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_QUERY_SERVICE_CONFIG(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependencies));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->startname));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->displayname));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->executablepath) {
@@ -795,6 +806,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, i
                } else {
                        r->displayname = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->executablepath) {
@@ -912,6 +924,7 @@ static enum ndr_err_code ndr_push_svcctl_ArgumentString(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -936,6 +949,7 @@ static enum ndr_err_code ndr_pull_svcctl_ArgumentString(struct ndr_pull *ndr, in
                } else {
                        r->string = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->string) {
@@ -1002,6 +1016,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVICE_DESCRIPTION(struct ndr_push *ndr, in
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1035,6 +1050,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_DESCRIPTION(struct ndr_pull *ndr, in
                        }
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1107,6 +1123,7 @@ static enum ndr_err_code ndr_push_SC_ACTION(struct ndr_push *ndr, int ndr_flags,
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_SC_ACTION_TYPE(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->delay));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1119,6 +1136,7 @@ static enum ndr_err_code ndr_pull_SC_ACTION(struct ndr_pull *ndr, int ndr_flags,
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_SC_ACTION_TYPE(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->delay));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1154,6 +1172,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVICE_FAILURE_ACTIONS(struct ndr_push *ndr
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_actions));
                NDR_CHECK(ndr_push_relative_ptr1(ndr, r->actions));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -1233,6 +1252,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_FAILURE_ACTIONS(struct ndr_pull *ndr
                } else {
                        r->actions = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {

diff --git a/librpc/gen_ndr/ndr_winreg.c b/librpc/gen_ndr/ndr_winreg.c
index e28e9ac7f0aa4cd7706ddd25e2876b717d261195..21d97b8756ff7a6caa43212caffe68087e08ad76 100644 (file)
--- a/librpc/gen_ndr/ndr_winreg.c
+++ b/librpc/gen_ndr/ndr_winreg.c
@@ -5,6 +5,7 @@
 
 #include "librpc/gen_ndr/ndr_lsa.h"
 #include "librpc/gen_ndr/ndr_security.h"
+#include "librpc/gen_ndr/ndr_misc.h"
 static enum ndr_err_code ndr_push_winreg_AccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -34,41 +35,6 @@ _PUBLIC_ void ndr_print_winreg_AccessMask(struct ndr_print *ndr, const char *nam
        ndr->depth--;
 }
 
-_PUBLIC_ enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r)
-{
-       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r)
-{
-       uint32_t v;
-       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
-       *r = v;
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r)
-{
-       const char *val = NULL;
-
-       switch (r) {
-               case REG_NONE: val = "REG_NONE"; break;
-               case REG_SZ: val = "REG_SZ"; break;
-               case REG_EXPAND_SZ: val = "REG_EXPAND_SZ"; break;
-               case REG_BINARY: val = "REG_BINARY"; break;
-               case REG_DWORD: val = "REG_DWORD"; break;
-               case REG_DWORD_BIG_ENDIAN: val = "REG_DWORD_BIG_ENDIAN"; break;
-               case REG_LINK: val = "REG_LINK"; break;
-               case REG_MULTI_SZ: val = "REG_MULTI_SZ"; break;
-               case REG_RESOURCE_LIST: val = "REG_RESOURCE_LIST"; break;
-               case REG_FULL_RESOURCE_DESCRIPTOR: val = "REG_FULL_RESOURCE_DESCRIPTOR"; break;
-               case REG_RESOURCE_REQUIREMENTS_LIST: val = "REG_RESOURCE_REQUIREMENTS_LIST"; break;
-               case REG_QWORD: val = "REG_QWORD"; break;
-       }
-       ndr_print_enum(ndr, name, "ENUM", val, r);
-}
-
 _PUBLIC_ enum ndr_err_code ndr_push_winreg_String(struct ndr_push *ndr, int ndr_flags, const struct winreg_String *r)
 {
        if (ndr_flags & NDR_SCALARS) {
@@ -76,6 +42,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_winreg_String(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -102,6 +69,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_winreg_String(struct ndr_pull *ndr, int ndr_
                } else {
                        r->name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -142,6 +110,7 @@ static enum ndr_err_code ndr_push_KeySecurityData(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -168,6 +137,7 @@ static enum ndr_err_code ndr_pull_KeySecurityData(struct ndr_pull *ndr, int ndr_
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -214,6 +184,7 @@ static enum ndr_err_code ndr_push_winreg_SecBuf(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
@@ -228,6 +199,7 @@ static enum ndr_err_code ndr_pull_winreg_SecBuf(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
@@ -278,6 +250,7 @@ static enum ndr_err_code ndr_push_winreg_StringBuf(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -304,6 +277,7 @@ static enum ndr_err_code ndr_pull_winreg_StringBuf(struct ndr_pull *ndr, int ndr
                } else {
                        r->name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -349,6 +323,7 @@ static enum ndr_err_code ndr_push_winreg_ValNameBuf(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -375,6 +350,7 @@ static enum ndr_err_code ndr_pull_winreg_ValNameBuf(struct ndr_pull *ndr, int nd
                } else {
                        r->name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -445,6 +421,7 @@ static enum ndr_err_code ndr_push_KeySecurityAttribute(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_size));
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
@@ -459,6 +436,7 @@ static enum ndr_err_code ndr_pull_KeySecurityAttribute(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_size));
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
@@ -484,6 +462,7 @@ static enum ndr_err_code ndr_push_QueryMultipleValue(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->offset));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -508,6 +487,7 @@ static enum ndr_err_code ndr_pull_QueryMultipleValue(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->offset));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {

diff --git a/librpc/gen_ndr/ndr_winreg.h b/librpc/gen_ndr/ndr_winreg.h
index a8766f4ccae7c1a00ffa704b1d4a6d4b17398c42..a496d4ccc65ec181c21dfb643be51424f497ade3 100644 (file)
--- a/librpc/gen_ndr/ndr_winreg.h
+++ b/librpc/gen_ndr/ndr_winreg.h
@@ -83,9 +83,6 @@ extern const struct ndr_interface_table ndr_table_winreg;
 
 #define NDR_WINREG_CALL_COUNT (35)
 void ndr_print_winreg_AccessMask(struct ndr_print *ndr, const char *name, uint32_t r);
-enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r);
-enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r);
-void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r);
 enum ndr_err_code ndr_push_winreg_String(struct ndr_push *ndr, int ndr_flags, const struct winreg_String *r);
 enum ndr_err_code ndr_pull_winreg_String(struct ndr_pull *ndr, int ndr_flags, struct winreg_String *r);
 void ndr_print_winreg_String(struct ndr_print *ndr, const char *name, const struct winreg_String *r);

diff --git a/librpc/gen_ndr/ndr_wkssvc.c b/librpc/gen_ndr/ndr_wkssvc.c
index fab7e5c5544734633584bf934ac4126a3b14c7b2..012f2966314d697ad35e662a630d2fba841dd80e 100644 (file)
--- a/librpc/gen_ndr/ndr_wkssvc.c
+++ b/librpc/gen_ndr/ndr_wkssvc.c
@@ -14,6 +14,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -55,6 +56,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, i
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -117,6 +119,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -172,6 +175,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, i
                } else {
                        r->lan_root = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -253,6 +257,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -309,6 +314,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, i
                        r->lan_root = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_name) {
@@ -419,6 +425,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -464,6 +471,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -517,6 +525,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -528,6 +537,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -547,6 +557,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -558,6 +569,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -577,6 +589,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -588,6 +601,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -607,6 +621,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -618,6 +633,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -637,6 +653,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -648,6 +665,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -667,6 +685,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -678,6 +697,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -697,6 +717,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -708,6 +729,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -727,6 +749,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1028(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->print_buf_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -738,6 +761,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1028(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->print_buf_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -757,6 +781,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1032(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wrk_heuristics));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -768,6 +793,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1032(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wrk_heuristics));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -787,6 +813,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -798,6 +825,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -817,6 +845,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1041(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -828,6 +857,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1041(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -847,6 +877,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1042(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -858,6 +889,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1042(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -877,6 +909,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1043(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -888,6 +921,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1043(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -907,6 +941,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1044(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -918,6 +953,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1044(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -937,6 +973,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1045(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -948,6 +985,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1045(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -967,6 +1005,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1046(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -978,6 +1017,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1046(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -997,6 +1037,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1047(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1008,6 +1049,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1047(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1027,6 +1069,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1048(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1038,6 +1081,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1048(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1057,6 +1101,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1049(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1068,6 +1113,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1049(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1087,6 +1133,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1050(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1098,6 +1145,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1050(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1117,6 +1165,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1051(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1128,6 +1177,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1051(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1147,6 +1197,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1052(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1158,6 +1209,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1052(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1177,6 +1229,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1053(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1188,6 +1241,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1053(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1207,6 +1261,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1054(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1218,6 +1273,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1054(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1237,6 +1293,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1055(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1248,6 +1305,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1055(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1267,6 +1325,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1056(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1278,6 +1337,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1056(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1297,6 +1357,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1057(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1308,6 +1369,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1057(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1327,6 +1389,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1058(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1338,6 +1401,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1058(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1357,6 +1421,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1059(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1368,6 +1433,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1059(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1387,6 +1453,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1060(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1398,6 +1465,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1060(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1417,6 +1485,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1061(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1428,6 +1497,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1061(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1447,6 +1517,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1062(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1458,6 +1529,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1062(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1477,6 +1549,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 100: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
@@ -1900,6 +1973,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 100: {
                                uint32_t _ptr_info100;
@@ -2941,6 +3015,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user_name) {
@@ -2965,6 +3040,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr
                } else {
                        r->user_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user_name) {
@@ -3003,6 +3079,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user0) {
@@ -3033,6 +3110,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *
                } else {
                        r->user0 = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user0) {
@@ -3090,6 +3168,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user_name) {
@@ -3156,6 +3235,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr
                } else {
                        r->logon_server = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user_name) {
@@ -3248,6 +3328,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user1) {
@@ -3278,6 +3359,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *
                } else {
                        r->user1 = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->user1) {
@@ -3332,6 +3414,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
@@ -3379,6 +3462,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_user0;
@@ -3467,6 +3551,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3481,6 +3566,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3503,6 +3589,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->other_domains) {
@@ -3527,6 +3614,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *
                } else {
                        r->other_domains = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->other_domains) {
@@ -3563,6 +3651,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -3621,6 +3710,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -3739,6 +3829,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -3780,6 +3871,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull
                        r->address = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -3839,6 +3931,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3869,6 +3962,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -3923,6 +4017,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -3959,6 +4054,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *n
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -4019,6 +4115,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -4033,6 +4130,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -4056,6 +4154,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->unknown1) {
@@ -4094,6 +4193,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int
                } else {
                        r->unknown2 = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->unknown1) {
@@ -4156,6 +4256,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->local) {
@@ -4240,6 +4341,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int
                } else {
                        r->domain_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->local) {
@@ -4358,6 +4460,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->local) {
@@ -4414,6 +4517,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->local) {
@@ -4491,6 +4595,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->local) {
@@ -4529,6 +4634,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int
                } else {
                        r->remote = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->local) {
@@ -4583,6 +4689,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
@@ -4652,6 +4759,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr,
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_info0;
@@ -4796,6 +4904,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4826,6 +4935,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4882,6 +4992,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4912,6 +5023,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4968,6 +5080,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -4998,6 +5111,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, i
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5052,6 +5166,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
@@ -5110,6 +5225,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, in
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 0: {
                                uint32_t _ptr_ctr0;
@@ -5226,6 +5342,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -5240,6 +5357,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
                NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -5301,6 +5419,7 @@ static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_pu
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5351,6 +5470,7 @@ static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pu
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5428,14 +5548,14 @@ _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *na
 
 static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -5457,14 +5577,14 @@ _PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const
 
 static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -5490,6 +5610,7 @@ static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, in
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_push_align(ndr, 1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
+                       NDR_CHECK(ndr_push_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -5506,6 +5627,7 @@ static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, in
                if (ndr_flags & NDR_SCALARS) {
                        NDR_CHECK(ndr_pull_align(ndr, 1));
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
+                       NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
                }
                if (ndr_flags & NDR_BUFFERS) {
                }
@@ -5561,14 +5683,14 @@ _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name
 
 static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)
 {
-       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -5593,6 +5715,7 @@ static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->computer_name) {
@@ -5623,6 +5746,7 @@ static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr,
                } else {
                        r->computer_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->computer_name) {

diff --git a/librpc/gen_ndr/ndr_xattr.c b/librpc/gen_ndr/ndr_xattr.c
index 33886499bdfba3fed3b798b1012cdce170cca9fe..6bcc831ded051e76a376d5ec36809444050b2dbf 100644 (file)
--- a/librpc/gen_ndr/ndr_xattr.c
+++ b/librpc/gen_ndr/ndr_xattr.c
@@ -14,6 +14,7 @@ static enum ndr_err_code ndr_push_xattr_DosInfo1(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -30,6 +31,7 @@ static enum ndr_err_code ndr_pull_xattr_DosInfo1(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -67,6 +69,7 @@ static enum ndr_err_code ndr_push_xattr_DosInfo2Old(struct ndr_push *ndr, int nd
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -91,6 +94,7 @@ static enum ndr_err_code ndr_pull_xattr_DosInfo2Old(struct ndr_pull *ndr, int nd
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -118,6 +122,7 @@ static enum ndr_err_code ndr_push_xattr_DosInfo(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -157,6 +162,7 @@ static enum ndr_err_code ndr_pull_xattr_DosInfo(struct ndr_pull *ndr, int ndr_fl
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
@@ -211,6 +217,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosAttrib(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
                NDR_CHECK(ndr_push_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -224,6 +231,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosAttrib(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
                NDR_CHECK(ndr_pull_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -251,6 +259,7 @@ static enum ndr_err_code ndr_push_xattr_EA(struct ndr_push *ndr, int ndr_flags,
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -268,6 +277,7 @@ static enum ndr_err_code ndr_pull_xattr_EA(struct ndr_pull *ndr, int ndr_flags,
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -290,6 +300,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosEAs(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_eas));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->eas));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->eas) {
@@ -317,6 +328,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosEAs(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->eas = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->eas) {
@@ -372,6 +384,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_tdb_xattrs(struct ndr_push *ndr, int ndr_fla
                for (cntr_eas_0 = 0; cntr_eas_0 < r->num_eas; cntr_eas_0++) {
                        NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -392,6 +405,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattrs(struct ndr_pull *ndr, int ndr_fla
                        NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -430,6 +444,7 @@ static enum ndr_err_code ndr_push_xattr_DosStream(struct ndr_push *ndr, int ndr_
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -449,6 +464,7 @@ static enum ndr_err_code ndr_pull_xattr_DosStream(struct ndr_pull *ndr, int ndr_
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
                        ndr->flags = _flags_save_string;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -473,6 +489,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosStreams(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_streams));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->streams));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->streams) {
@@ -500,6 +517,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosStreams(struct ndr_pull *ndr, int n
                } else {
                        r->streams = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->streams) {
@@ -552,6 +570,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v2(struct ndr_push
                NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sd) {
@@ -574,6 +593,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v2(struct ndr_pull
                        r->sd = NULL;
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sd) {
@@ -607,6 +627,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v3(struct ndr_push
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hash_type));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 64));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sd) {
@@ -630,6 +651,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v3(struct ndr_pull
                }
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hash_type));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 64));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->sd) {
@@ -662,6 +684,7 @@ static enum ndr_err_code ndr_push_xattr_NTACL_Info(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
@@ -720,6 +743,7 @@ static enum ndr_err_code ndr_pull_xattr_NTACL_Info(struct ndr_pull *ndr, int ndr
                if (_level != level) {
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_sd;
@@ -836,6 +860,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_xattr_NTACL(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
                NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
@@ -850,6 +875,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_xattr_NTACL(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
                NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));

diff --git a/librpc/gen_ndr/netlogon.h b/librpc/gen_ndr/netlogon.h
index 890fba1779500594fa6c73587ffb5424923e7b85..402e4a0d2903ed97603ce648f8bd13a64f387b94 100644 (file)
--- a/librpc/gen_ndr/netlogon.h
+++ b/librpc/gen_ndr/netlogon.h
@@ -17,6 +17,7 @@
 #define NETLOGON_NEG_128BIT    ( NETLOGON_NEG_STRONG_KEYS )
 #define NETLOGON_NEG_SCHANNEL  ( NETLOGON_NEG_AUTHENTICATED_RPC )
 #define DSGETDC_VALID_FLAGS    ( (DS_FORCE_REDISCOVERY|DS_DIRECTORY_SERVICE_REQUIRED|DS_DIRECTORY_SERVICE_PREFERRED|DS_GC_SERVER_REQUIRED|DS_PDC_REQUIRED|DS_BACKGROUND_ONLY|DS_IP_REQUIRED|DS_KDC_REQUIRED|DS_TIMESERV_REQUIRED|DS_WRITABLE_REQUIRED|DS_GOOD_TIMESERV_PREFERRED|DS_AVOID_SELF|DS_ONLY_LDAP_NEEDED|DS_IS_FLAT_NAME|DS_IS_DNS_NAME|DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME) )
+#define NETLOGON_PASSWORD_VERSION_NUMBER_PRESENT       ( 0x02231968 )
 #define DS_GFTI_UPDATE_TDO     ( 0x1 )
 struct netr_UasInfo {
        const char *account_name;/* [unique,charset(UTF16)] */
@@ -865,9 +866,9 @@ enum netr_DsRGetDCNameInfo_AddressType
 #define DS_SERVER_NDNC ( NBT_SERVER_NDNC )
 #define DS_SERVER_SELECT_SECRET_DOMAIN_6 ( NBT_SERVER_SELECT_SECRET_DOMAIN_6 )
 #define DS_SERVER_FULL_SECRET_DOMAIN_6 ( NBT_SERVER_FULL_SECRET_DOMAIN_6 )
-#define DS_DNS_CONTROLLER ( 0x20000000 )
-#define DS_DNS_DOMAIN ( 0x40000000 )
-#define DS_DNS_FOREST ( 0x80000000 )
+#define DS_DNS_CONTROLLER ( NBT_SERVER_HAS_DNS_NAME )
+#define DS_DNS_DOMAIN ( NBT_SERVER_IS_DEFAULT_NC )
+#define DS_DNS_FOREST_ROOT ( NBT_SERVER_FOREST_ROOT )
 
 struct netr_DsRGetDCNameInfo {
        const char *dc_unc;/* [unique,charset(UTF16)] */
@@ -1033,6 +1034,12 @@ union netr_DomainInfo {
        struct netr_LsaPolicyInformation *lsa_policy_info;/* [unique,case(2)] */
 };
 
+struct NL_PASSWORD_VERSION {
+       uint32_t ReservedField;
+       uint32_t PasswordVersionNumber;
+       uint32_t PasswordVersionPresent;
+};
+
 struct netr_CryptPassword {
        uint8_t data[512];
        uint32_t length;

diff --git a/librpc/gen_ndr/ntsvcs.h b/librpc/gen_ndr/ntsvcs.h
index f59fcae2e7f89a1f13ccf7f9819c1ba0dd822ea0..76b2628a66299c04d479d8150efd2c4e7a79ee0c 100644 (file)
--- a/librpc/gen_ndr/ntsvcs.h
+++ b/librpc/gen_ndr/ntsvcs.h
@@ -4,7 +4,7 @@
 
 #include "libcli/util/ntstatus.h"
 
-#include "librpc/gen_ndr/winreg.h"
+#include "librpc/gen_ndr/misc.h"
 #ifndef _HEADER_ntsvcs
 #define _HEADER_ntsvcs
 

diff --git a/librpc/gen_ndr/samr.h b/librpc/gen_ndr/samr.h
index 33b21d2d054ac045c2991570dcc7d8e3f60c9374..75462dec7308076cb0fa66d67bb70d3288bc45b4 100644 (file)
--- a/librpc/gen_ndr/samr.h
+++ b/librpc/gen_ndr/samr.h
@@ -53,23 +53,6 @@ enum netr_SamDatabaseID
 #endif
 ;
 
-enum samr_RejectReason
-#ifndef USE_UINT_ENUMS
- {
-       SAMR_REJECT_OTHER=(int)(0),
-       SAMR_REJECT_TOO_SHORT=(int)(1),
-       SAMR_REJECT_IN_HISTORY=(int)(2),
-       SAMR_REJECT_COMPLEXITY=(int)(5)
-}
-#else
- { __donnot_use_enum_samr_RejectReason=0x7FFFFFFF}
-#define SAMR_REJECT_OTHER ( 0 )
-#define SAMR_REJECT_TOO_SHORT ( 1 )
-#define SAMR_REJECT_IN_HISTORY ( 2 )
-#define SAMR_REJECT_COMPLEXITY ( 5 )
-#endif
-;
-
 /* bitmap samr_AcctFlags */
 #define ACB_DISABLED ( 0x00000001 )
 #define ACB_HOMDIRREQ ( 0x00000002 )
@@ -790,10 +773,36 @@ enum samr_ConnectVersion
 #endif
 ;
 
-struct samr_ChangeReject {
-       enum samr_RejectReason reason;
-       uint32_t unknown1;
-       uint32_t unknown2;
+enum samPwdChangeReason
+#ifndef USE_UINT_ENUMS
+ {
+       SAM_PWD_CHANGE_NO_ERROR=(int)(0),
+       SAM_PWD_CHANGE_PASSWORD_TOO_SHORT=(int)(1),
+       SAM_PWD_CHANGE_PWD_IN_HISTORY=(int)(2),
+       SAM_PWD_CHANGE_USERNAME_IN_PASSWORD=(int)(3),
+       SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD=(int)(4),
+       SAM_PWD_CHANGE_NOT_COMPLEX=(int)(5),
+       SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT=(int)(6),
+       SAM_PWD_CHANGE_FAILED_BY_FILTER=(int)(7),
+       SAM_PWD_CHANGE_PASSWORD_TOO_LONG=(int)(8)
+}
+#else
+ { __donnot_use_enum_samPwdChangeReason=0x7FFFFFFF}
+#define SAM_PWD_CHANGE_NO_ERROR ( 0 )
+#define SAM_PWD_CHANGE_PASSWORD_TOO_SHORT ( 1 )
+#define SAM_PWD_CHANGE_PWD_IN_HISTORY ( 2 )
+#define SAM_PWD_CHANGE_USERNAME_IN_PASSWORD ( 3 )
+#define SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD ( 4 )
+#define SAM_PWD_CHANGE_NOT_COMPLEX ( 5 )
+#define SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT ( 6 )
+#define SAM_PWD_CHANGE_FAILED_BY_FILTER ( 7 )
+#define SAM_PWD_CHANGE_PASSWORD_TOO_LONG ( 8 )
+#endif
+;
+
+struct userPwdChangeFailureInformation {
+       enum samPwdChangeReason extendedFailureReason;
+       const char *filterModuleName;/* [unique,charset(UTF16)] */
 };
 
 struct samr_ConnectInfo1 {
@@ -1852,7 +1861,7 @@ struct samr_ChangePasswordUser3 {
 
        struct {
                struct samr_DomInfo1 **dominfo;/* [ref] */
-               struct samr_ChangeReject **reject;/* [ref] */
+               struct userPwdChangeFailureInformation **reject;/* [ref] */
                NTSTATUS result;
        } out;
 

diff --git a/librpc/gen_ndr/security.h b/librpc/gen_ndr/security.h
index 05df02ae8f567463962395d0dfc0cbd95aec948b..297ba18d7f03c49384214527330974b57c5fb104 100644 (file)
--- a/librpc/gen_ndr/security.h
+++ b/librpc/gen_ndr/security.h
@@ -70,6 +70,10 @@
 #define SEC_RIGHTS_DIR_WRITE   ( SEC_RIGHTS_FILE_WRITE )
 #define SEC_RIGHTS_DIR_EXECUTE ( SEC_RIGHTS_FILE_EXECUTE )
 #define SEC_RIGHTS_DIR_ALL     ( SEC_RIGHTS_FILE_ALL )
+#define SEC_RIGHTS_PRIV_BACKUP ( SEC_STD_READ_CONTROL|SEC_FLAG_SYSTEM_SECURITY|SEC_GENERIC_READ )
+#define SEC_RIGHTS_DIR_PRIV_BACKUP     ( SEC_RIGHTS_PRIV_BACKUP|SEC_DIR_TRAVERSE )
+#define SEC_RIGHTS_PRIV_RESTORE        ( SEC_STD_WRITE_DAC|SEC_STD_WRITE_OWNER|SEC_FLAG_SYSTEM_SECURITY|SEC_STD_DELETE )
+#define SEC_RIGHTS_DIR_PRIV_RESTORE    ( SEC_RIGHTS_PRIV_RESTORE|SEC_DIR_ADD_FILE|SEC_DIR_ADD_SUBDIR )
 #define STANDARD_RIGHTS_ALL_ACCESS     ( SEC_STD_ALL )
 #define STANDARD_RIGHTS_MODIFY_ACCESS  ( SEC_STD_READ_CONTROL )
 #define STANDARD_RIGHTS_EXECUTE_ACCESS ( SEC_STD_READ_CONTROL )

diff --git a/librpc/gen_ndr/srv_samr.c b/librpc/gen_ndr/srv_samr.c
index e1b6951b3cca9c25e8804624f3dc5b7ebc358546..eba50b3e111a47856c69dcf7348b1d02cfb3675a 100644 (file)
--- a/librpc/gen_ndr/srv_samr.c
+++ b/librpc/gen_ndr/srv_samr.c
@@ -5030,7 +5030,7 @@ static bool api_samr_ChangePasswordUser3(pipes_struct *p)
                return false;
        }
 
-       r->out.reject = talloc_zero(r, struct samr_ChangeReject *);
+       r->out.reject = talloc_zero(r, struct userPwdChangeFailureInformation *);
        if (r->out.reject == NULL) {
                talloc_free(r);
                return false;
@@ -6195,7 +6195,7 @@ NTSTATUS rpc_samr_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, con
                        return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.reject = talloc_zero(mem_ctx, struct samr_ChangeReject *);
+                       r->out.reject = talloc_zero(mem_ctx, struct userPwdChangeFailureInformation *);
                        if (r->out.reject == NULL) {
                        return NT_STATUS_NO_MEMORY;
                        }

diff --git a/librpc/gen_ndr/winreg.h b/librpc/gen_ndr/winreg.h
index 99629270089c341f4774a4a00fb1fcd5b8b55762..71168107087b1960f95c062b70b100e6850b24ed 100644 (file)
--- a/librpc/gen_ndr/winreg.h
+++ b/librpc/gen_ndr/winreg.h
@@ -6,6 +6,7 @@
 
 #include "librpc/gen_ndr/lsa.h"
 #include "librpc/gen_ndr/security.h"
+#include "librpc/gen_ndr/misc.h"
 #ifndef _HEADER_winreg
 #define _HEADER_winreg
 
@@ -23,39 +24,6 @@
 #define KEY_WOW64_64KEY ( 0x00100 )
 #define KEY_WOW64_32KEY ( 0x00200 )
 
-enum winreg_Type
-#ifndef USE_UINT_ENUMS
- {
-       REG_NONE=(int)(0),
-       REG_SZ=(int)(1),
-       REG_EXPAND_SZ=(int)(2),
-       REG_BINARY=(int)(3),
-       REG_DWORD=(int)(4),
-       REG_DWORD_BIG_ENDIAN=(int)(5),
-       REG_LINK=(int)(6),
-       REG_MULTI_SZ=(int)(7),
-       REG_RESOURCE_LIST=(int)(8),
-       REG_FULL_RESOURCE_DESCRIPTOR=(int)(9),
-       REG_RESOURCE_REQUIREMENTS_LIST=(int)(10),
-       REG_QWORD=(int)(11)
-}
-#else
- { __donnot_use_enum_winreg_Type=0x7FFFFFFF}
-#define REG_NONE ( 0 )
-#define REG_SZ ( 1 )
-#define REG_EXPAND_SZ ( 2 )
-#define REG_BINARY ( 3 )
-#define REG_DWORD ( 4 )
-#define REG_DWORD_BIG_ENDIAN ( 5 )
-#define REG_LINK ( 6 )
-#define REG_MULTI_SZ ( 7 )
-#define REG_RESOURCE_LIST ( 8 )
-#define REG_FULL_RESOURCE_DESCRIPTOR ( 9 )
-#define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
-#define REG_QWORD ( 11 )
-#endif
-;
-
 struct winreg_String {
        uint16_t name_len;/* [value(strlen_m_term(name)*2)] */
        uint16_t name_size;/* [value(strlen_m_term(name)*2)] */

diff --git a/librpc/idl/drsuapi.idl b/librpc/idl/drsuapi.idl
index 9d2d1534188d659e70059bfb1603e30d6bba989f..f53db00f5b81be8c9884afe00e5c8cbf8c4f8c55 100644 (file)
--- a/librpc/idl/drsuapi.idl
+++ b/librpc/idl/drsuapi.idl
@@ -15,6 +15,40 @@ interface drsuapi
 {
        typedef bitmap samr_GroupAttrs samr_GroupAttrs;
 
+       /* see MS-DRSR section 5.37 */
+       typedef [public,bitmap32bit] bitmap {
+               DRSUAPI_DRS_ASYNC_OP                  = 0x00000001,
+               DRSUAPI_DRS_GETCHG_CHECK              = 0x00000002,
+               DRSUAPI_DRS_ADD_REF                   = 0x00000004,
+               DRSUAPI_DRS_SYNC_ALL                  = 0x00000008,
+               DRSUAPI_DRS_DEL_REF                   = 0x00000008,
+               DRSUAPI_DRS_WRIT_REP                  = 0x00000010,
+               DRSUAPI_DRS_INIT_SYNC                 = 0x00000020,
+               DRSUAPI_DRS_PER_SYNC                  = 0x00000040,
+               DRSUAPI_DRS_MAIL_REP                  = 0x00000080,
+               DRSUAPI_DRS_ASYNC_REP                 = 0x00000100,
+               DRSUAPI_DRS_IGNORE_ERROR              = 0x00000100,
+               DRSUAPI_DRS_TWOWAY_SYNC               = 0x00000200,
+               DRSUAPI_DRS_CRITICAL_ONLY             = 0x00000400,
+               DRSUAPI_DRS_GET_ANC                   = 0x00000800,
+               DRSUAPI_DRS_GET_NC_SIZE               = 0x00001000,
+               DRSUAPI_DRS_LOCAL_ONLY                = 0x00001000,
+               DRSUAPI_DRS_SYNC_BYNAME               = 0x00004000,
+               DRSUAPI_DRS_REF_OK                    = 0x00004000,
+               DRSUAPI_DRS_FULL_SYNC_NOW             = 0x00008000,
+               DRSUAPI_DRS_NO_SOURCE                 = 0x00008000,
+               DRSUAPI_DRS_FULL_SYNC_PACKET          = 0x00020000,
+               DRSUAPI_DRS_REF_GCSPN                 = 0x00100000,
+               DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING = 0x00800000,
+               DRSUAPI_DRS_SYNC_FORCED               = 0x02000000,
+               DRSUAPI_DRS_DISABLE_AUTO_SYNC         = 0x04000000,
+               DRSUAPI_DRS_DISABLE_PERIODIC_SYNC     = 0x08000000,
+               DRSUAPI_DRS_USE_COMPRESSION           = 0x10000000,
+               DRSUAPI_DRS_NEVER_NOTIFY              = 0x20000000,
+               DRSUAPI_DRS_SYNC_PAS                  = 0x40000000,
+               DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP  = 0x80000000
+       } drsuapi_DrsOptions;
+
        /*****************/
         /* Function 0x00 */
         typedef [bitmap32bit] bitmap {
@@ -219,6 +253,8 @@ interface drsuapi
                /* the _WRITEABLE flag indicates a replication with all attributes
                 *
                 * --metze
+                *
+                * See drsuapi_DrsOptions for the WSPP bit names 
                 */
                DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE                          = 0x00000010,
                DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP                    = 0x00000020,
@@ -378,9 +414,9 @@ interface drsuapi
         *
         * 2.5.5.17     => dom_sid
         */
-       typedef [nopush,nopull] struct {
-               [range(0,10000),value(ndr_size_drsuapi_DsReplicaOID_oid(oid, 0))] uint32 __ndr_size;
-               [size_is(__ndr_size),charset(DOS)] uint8 *oid; /* it's encoded with asn1_write_OID_String() */
+       typedef [noprint] struct {
+               [range(0,10000)] uint32 length;
+               [size_is(length)] uint8 *binary_oid; /* partial-binary-OID encoded with asn1_write_partial_OID_String() */
        } drsuapi_DsReplicaOID;
 
        typedef struct {

diff --git a/librpc/idl/lsa.idl b/librpc/idl/lsa.idl
index 253b6d780c82d0a5a16ff9317d914c78a0b80735..58e0ea9e26cc2371e5f2f3426c668a9af6824009 100644 (file)
--- a/librpc/idl/lsa.idl
+++ b/librpc/idl/lsa.idl
@@ -113,14 +113,14 @@ import "misc.idl", "security.idl";
        /******************/
        /* Function: 0x06 */
        typedef struct {
-               uint32  len; /* ignored */
+               uint3264  len; /* ignored */
                uint16  impersonation_level;
                uint8   context_mode;
                uint8   effective_only;
        } lsa_QosInfo;
 
        typedef struct {
-               uint32 len; /* ignored */
+               uint3264 len; /* ignored */
                uint8 *root_dir;
                [string,charset(UTF16)] uint16 *object_name;
                uint32 attributes;
@@ -628,8 +628,8 @@ import "misc.idl", "security.idl";
                );
 
        typedef [flag(NDR_PAHEX)] struct {
-               uint32 length;
-               uint32 size;
+               uint3264 length;
+               uint3264 size;
                [size_is(size),length_is(length)] uint8 *data;
        } lsa_DATA_BUF;
 
@@ -1220,7 +1220,7 @@ import "misc.idl", "security.idl";
 
        /* Function 0x49 */
        typedef struct {
-               [range(0,131072)] uint32 length;
+               [range(0,131072)] uint3264 length;
                [size_is(length)] uint8 *data;
        } lsa_ForestTrustBinaryData;
 

diff --git a/librpc/idl/misc.idl b/librpc/idl/misc.idl
index 5bc3c9f976c886146caa6136ebb0d38077cbc2e2..5a2bf75a74ad214ae9d0a3f231f06be714a7233e 100644 (file)
--- a/librpc/idl/misc.idl
+++ b/librpc/idl/misc.idl
@@ -1,3 +1,5 @@
+#include "idl_types.h"
+
 /*
   miscellaneous IDL structures
 */
@@ -43,4 +45,28 @@ interface misc
                uint32 unknown1;
                uint32 unknown2; /* 0x00000001 */
        } KRB5_EDATA_NTSTATUS;
+
+       typedef [public,v1_enum] enum {
+               REG_NONE                       = 0,
+               REG_SZ                         = 1,
+               REG_EXPAND_SZ                  = 2,
+               REG_BINARY                     = 3,
+               REG_DWORD                      = 4,
+               REG_DWORD_BIG_ENDIAN           = 5,
+               REG_LINK                       = 6,
+               REG_MULTI_SZ                   = 7,
+               REG_RESOURCE_LIST              = 8,
+               REG_FULL_RESOURCE_DESCRIPTOR   = 9,
+               REG_RESOURCE_REQUIREMENTS_LIST = 10,
+               REG_QWORD                      = 11
+       } winreg_Type;
+
+       typedef [nodiscriminant,public] union {
+               [case(REG_NONE)];
+               [case(REG_SZ)] nstring string;
+               [case(REG_BINARY),flag(NDR_REMAINING)] DATA_BLOB binary;
+               [case(REG_DWORD)] uint32 value;
+               [case(REG_MULTI_SZ)] nstring_array string_array;
+               [default,flag(NDR_REMAINING)] DATA_BLOB data;
+       } winreg_Data;
 }

diff --git a/librpc/idl/nbt.idl b/librpc/idl/nbt.idl
index fc82b1c8977e88a095827a033dac880c30ff4479..a51132c4d4796df0116bf44fba223ef265cf99ec 100644 (file)
--- a/librpc/idl/nbt.idl
+++ b/librpc/idl/nbt.idl
@@ -357,7 +357,10 @@ interface nbt
                NBT_SERVER_NDNC                         = 0x00000400,
                NBT_SERVER_SELECT_SECRET_DOMAIN_6       = 0x00000800,
                NBT_SERVER_FULL_SECRET_DOMAIN_6         = 0x00001000,
-               NBT_SERVER_DNS_FOREST                   = 0x01000000
+               NBT_SERVER_ADS_WEB_SERVICE              = 0x00002000,
+               NBT_SERVER_HAS_DNS_NAME                 = 0x20000000,
+               NBT_SERVER_IS_DEFAULT_NC                = 0x40000000,
+               NBT_SERVER_FOREST_ROOT                  = 0x80000000
        } nbt_server_type;
 
        typedef [bitmap32bit,public] bitmap {

diff --git a/librpc/idl/netlogon.idl b/librpc/idl/netlogon.idl
index ef2c8a47218dde84508e7d19bd2dc67aba4d0976..82a60c7c3e422a95204ba945e9517f4a982db0aa 100644 (file)
--- a/librpc/idl/netlogon.idl
+++ b/librpc/idl/netlogon.idl
@@ -1142,9 +1142,9 @@ interface netlogon
                DS_SERVER_NDNC                   = NBT_SERVER_NDNC,
                DS_SERVER_SELECT_SECRET_DOMAIN_6 = NBT_SERVER_SELECT_SECRET_DOMAIN_6,
                DS_SERVER_FULL_SECRET_DOMAIN_6   = NBT_SERVER_FULL_SECRET_DOMAIN_6,
-               DS_DNS_CONTROLLER                = 0x20000000,
-               DS_DNS_DOMAIN                    = 0x40000000,
-               DS_DNS_FOREST                    = 0x80000000
+               DS_DNS_CONTROLLER                = NBT_SERVER_HAS_DNS_NAME,
+               DS_DNS_DOMAIN                    = NBT_SERVER_IS_DEFAULT_NC,
+               DS_DNS_FOREST_ROOT               = NBT_SERVER_FOREST_ROOT
        } netr_DsR_DcFlags;
 
        typedef [public] struct {
@@ -1412,6 +1412,18 @@ interface netlogon
 
        /*****************/
        /* Function 0x1e */
+
+       /* [MS-NRPC] 2.2.1.3.8 NL_PASSWORD_VERSION */
+
+       /* someone's birthday ? */
+       const int NETLOGON_PASSWORD_VERSION_NUMBER_PRESENT = 0x02231968;
+
+       typedef struct {
+               uint32 ReservedField;
+               uint32 PasswordVersionNumber;
+               uint32 PasswordVersionPresent;
+       } NL_PASSWORD_VERSION;
+
        typedef [flag(NDR_PAHEX)] struct {
                uint8 data[512];
                uint32 length;

diff --git a/librpc/idl/ntsvcs.idl b/librpc/idl/ntsvcs.idl
index b1a3b78c3449a04e272c968c4671e8976eb25838..91a85b96b935dd50767ffccf27c49543be4a8f75 100644 (file)
--- a/librpc/idl/ntsvcs.idl
+++ b/librpc/idl/ntsvcs.idl
@@ -2,7 +2,7 @@
   plug and play services
 */
 
-import "winreg.idl";
+import "misc.idl";
 
 [
   uuid("8d9f4e40-a03d-11ce-8f69-08003e30051b"),

diff --git a/librpc/idl/samr.idl b/librpc/idl/samr.idl
index 8a5692fe17d48f36fec27ff0e29d7e8c84b5620b..da7b1aa82e119c8d729d14a87460c616fb850cee 100644 (file)
--- a/librpc/idl/samr.idl
+++ b/librpc/idl/samr.idl
@@ -24,15 +24,6 @@ import "misc.idl", "lsa.idl", "security.idl";
                SAM_DATABASE_PRIVS   = 2 /* Privileges */
        } netr_SamDatabaseID;
 
-       typedef [public,v1_enum] enum {
-               SAMR_REJECT_OTHER      = 0,
-               SAMR_REJECT_TOO_SHORT  = 1,
-               SAMR_REJECT_IN_HISTORY = 2,
-               SAMR_REJECT_COMPLEXITY = 5
-       } samr_RejectReason;
-
-
-
        /* account control (acct_flags) bits */
        typedef [public,bitmap32bit] bitmap {
                ACB_DISABLED                    = 0x00000001,  /* 1 = User account disabled */
@@ -1447,13 +1438,22 @@ import "misc.idl", "lsa.idl", "security.idl";
        /************************/
        /* Function    0x3f     */
 
-       typedef enum samr_RejectReason samr_RejectReason;
+       typedef [public,v1_enum] enum {
+               SAM_PWD_CHANGE_NO_ERROR             = 0,
+               SAM_PWD_CHANGE_PASSWORD_TOO_SHORT   = 1,
+               SAM_PWD_CHANGE_PWD_IN_HISTORY       = 2,
+               SAM_PWD_CHANGE_USERNAME_IN_PASSWORD = 3,
+               SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD = 4,
+               SAM_PWD_CHANGE_NOT_COMPLEX          = 5,
+               SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT  = 6,
+               SAM_PWD_CHANGE_FAILED_BY_FILTER     = 7,
+               SAM_PWD_CHANGE_PASSWORD_TOO_LONG    = 8
+       } samPwdChangeReason;
 
        typedef struct {
-               samr_RejectReason reason;
-               uint32 unknown1;
-               uint32 unknown2;
-       } samr_ChangeReject;
+               samPwdChangeReason extendedFailureReason;
+               [string,charset(UTF16)] uint16 *filterModuleName;
+       } userPwdChangeFailureInformation;
 
        NTSTATUS samr_ChangePasswordUser3(
                [in,unique]       lsa_String *server,
@@ -1465,7 +1465,7 @@ import "misc.idl", "lsa.idl", "security.idl";
                [in,unique]       samr_Password *lm_verifier,
                [in,unique]       samr_CryptPassword *password3,
                [out,ref]         samr_DomInfo1 **dominfo,
-               [out,ref]         samr_ChangeReject **reject
+               [out,ref]         userPwdChangeFailureInformation **reject
                );
 
        /************************/

diff --git a/librpc/idl/security.idl b/librpc/idl/security.idl
index 96d24b66859bb9578292c080c33530de019343e8..c24dc64bd79897fe3d1ec2c4741cb69a601c0f4a 100644 (file)
--- a/librpc/idl/security.idl
+++ b/librpc/idl/security.idl
@@ -144,6 +144,21 @@ interface security
        const int SEC_RIGHTS_DIR_EXECUTE  = SEC_RIGHTS_FILE_EXECUTE;
        const int SEC_RIGHTS_DIR_ALL      = SEC_RIGHTS_FILE_ALL;
 
+       /* rights granted by some specific privileges */
+       const int SEC_RIGHTS_PRIV_BACKUP  = SEC_STD_READ_CONTROL | 
+                                           SEC_FLAG_SYSTEM_SECURITY |
+                                           SEC_GENERIC_READ;
+       const int SEC_RIGHTS_DIR_PRIV_BACKUP  = SEC_RIGHTS_PRIV_BACKUP 
+                                             | SEC_DIR_TRAVERSE;
+
+       const int SEC_RIGHTS_PRIV_RESTORE = SEC_STD_WRITE_DAC | 
+                                           SEC_STD_WRITE_OWNER |
+                                           SEC_FLAG_SYSTEM_SECURITY |
+                                           SEC_STD_DELETE;
+       const int SEC_RIGHTS_DIR_PRIV_RESTORE = SEC_RIGHTS_PRIV_RESTORE | 
+                                           SEC_DIR_ADD_FILE |
+                                           SEC_DIR_ADD_SUBDIR;
+
        /* combinations of standard masks. */
        const int STANDARD_RIGHTS_ALL_ACCESS            = SEC_STD_ALL; /* 0x001f0000 */
        const int STANDARD_RIGHTS_MODIFY_ACCESS         = SEC_STD_READ_CONTROL; /* 0x00020000 */

diff --git a/librpc/idl/winreg.idl b/librpc/idl/winreg.idl
index 18b5edcb5d98d7198027b4f6f8c6f3d36832a4b7..f1f4dfb719e022327e7a1c24012a031e530d4714 100644 (file)
--- a/librpc/idl/winreg.idl
+++ b/librpc/idl/winreg.idl
@@ -2,7 +2,7 @@
   winreg interface definition
 */
 
-import "lsa.idl", "security.idl";
+import "lsa.idl", "security.idl", "misc.idl";
 
 [ 
   uuid("338cd001-2244-31f1-aaaa-900038001003"),
@@ -45,21 +45,6 @@ import "lsa.idl", "security.idl";
                                        REG_KEY_WRITE                   |
                                        KEY_CREATE_LINK);
 
-       typedef [public,v1_enum] enum {
-               REG_NONE                       = 0,
-               REG_SZ                         = 1,
-               REG_EXPAND_SZ                  = 2,
-               REG_BINARY                     = 3,
-               REG_DWORD                      = 4,
-               REG_DWORD_BIG_ENDIAN           = 5,
-               REG_LINK                       = 6,
-               REG_MULTI_SZ                   = 7,
-               REG_RESOURCE_LIST              = 8,
-               REG_FULL_RESOURCE_DESCRIPTOR   = 9,
-               REG_RESOURCE_REQUIREMENTS_LIST = 10,
-               REG_QWORD                      = 11
-       } winreg_Type;
-
        typedef [public] struct {
                [value(strlen_m_term(name)*2)] uint16 name_len;
                [value(strlen_m_term(name)*2)] uint16 name_size;

diff --git a/librpc/ndr/libndr.h b/librpc/ndr/libndr.h
index 03b4362b37626b9a69779531122d1b783b94338e..45cb24405f3c3af0602745098244b2d88893eb99 100644 (file)
--- a/librpc/ndr/libndr.h
+++ b/librpc/ndr/libndr.h
@@ -467,9 +467,11 @@ NDR_SCALAR_PROTO(uint8, uint8_t)
 NDR_SCALAR_PROTO(int8, int8_t)
 NDR_SCALAR_PROTO(uint16, uint16_t)
 NDR_SCALAR_PROTO(int16, int16_t)
+NDR_SCALAR_PROTO(uint1632, uint16_t)
 NDR_SCALAR_PROTO(uint32, uint32_t)
 NDR_SCALAR_PROTO(uint3264, uint32_t)
 NDR_SCALAR_PROTO(int32, int32_t)
+NDR_SCALAR_PROTO(int3264, int32_t)
 NDR_SCALAR_PROTO(udlong, uint64_t)
 NDR_SCALAR_PROTO(udlongr, uint64_t)
 NDR_SCALAR_PROTO(dlong, int64_t)
@@ -498,6 +500,10 @@ enum ndr_err_code ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n
 enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *data, uint32_t n);
 enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size);
 enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size);
+enum ndr_err_code ndr_push_union_align(struct ndr_push *ndr, size_t size);
+enum ndr_err_code ndr_pull_union_align(struct ndr_pull *ndr, size_t size);
+enum ndr_err_code ndr_push_trailer_align(struct ndr_push *ndr, size_t size);
+enum ndr_err_code ndr_pull_trailer_align(struct ndr_pull *ndr, size_t size);
 enum ndr_err_code ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n);
 enum ndr_err_code ndr_push_zero(struct ndr_push *ndr, uint32_t n);
 enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const uint8_t *data, uint32_t n);
@@ -544,8 +550,10 @@ struct GUID GUID_random(void);
 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v);
 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v);
 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v);
+_PUBLIC_ enum ndr_err_code ndr_pull_enum_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v);
 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v);
 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v);
 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v);
+_PUBLIC_ enum ndr_err_code ndr_push_enum_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v);
 
 #endif /* __LIBNDR_H__ */

diff --git a/librpc/ndr/ndr_basic.c b/librpc/ndr/ndr_basic.c
index 00e33ad9d03575e462ee6639b1274f4bbd9a521e..64fa5a62998268b8977683b1befde75bdb8fcef9 100644 (file)
--- a/librpc/ndr/ndr_basic.c
+++ b/librpc/ndr/ndr_basic.c
@@ -101,6 +101,24 @@ _PUBLIC_ enum ndr_err_code ndr_pull_uint16(struct ndr_pull *ndr, int ndr_flags,
        return NDR_ERR_SUCCESS;
 }
 
+/*
+  parse a uint1632_t
+*/
+_PUBLIC_ enum ndr_err_code ndr_pull_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
+{
+       if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
+               uint32_t v32 = 0;
+               enum ndr_err_code err = ndr_pull_uint32(ndr, ndr_flags, &v32);
+               *v = v32;
+               if (unlikely(v32 != *v)) {
+                       DEBUG(0,(__location__ ": non-zero upper 16 bits 0x%08x\n", (unsigned)v32));
+                       return NDR_ERR_NDR64;
+               }
+               return err;
+       }
+       return ndr_pull_uint16(ndr, ndr_flags, v);
+}
+
 /*
   parse a int32_t
 */
@@ -282,9 +300,17 @@ _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, int ndr_fla
 }
 
 /*
-  parse a uint16_t enum (uint32_t on NDR64)
+  parse a uint16_t enum
 */
 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
+{
+       return ndr_pull_uint16(ndr, ndr_flags, v);
+}
+
+/*
+  parse a uint1632_t enum (uint32_t on NDR64)
+*/
+_PUBLIC_ enum ndr_err_code ndr_pull_enum_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
 {
        if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
                uint32_t v32;
@@ -296,11 +322,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, int ndr_fl
                }
                return NDR_ERR_SUCCESS;
        }
-       NDR_PULL_ALIGN(ndr, 2);
-       NDR_PULL_NEED_BYTES(ndr, 2);
-       *v = NDR_SVAL(ndr, ndr->offset);
-       ndr->offset += 2;
-       return NDR_ERR_SUCCESS;
+       return ndr_pull_uint16(ndr, ndr_flags, v);
 }
 
 /*
@@ -320,13 +342,10 @@ _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, int ndr_fla
 }
 
 /*
-  push a uint16_t enum (uint32_t on NDR64)
+  push a uint16_t enum
 */
 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 {
-       if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
-               return ndr_push_uint32(ndr, ndr_flags, v);
-       }
        return ndr_push_uint16(ndr, ndr_flags, v);
 }
 
@@ -338,6 +357,16 @@ _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, int ndr_fl
        return ndr_push_uint32(ndr, ndr_flags, v);
 }
 
+/*
+  push a uint1632_t enum
+*/
+_PUBLIC_ enum ndr_err_code ndr_push_enum_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v)
+{
+       if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
+               return ndr_push_uint32(ndr, ndr_flags, v);
+       }
+       return ndr_push_uint16(ndr, ndr_flags, v);
+}
 
 /*
   push a WERROR
@@ -420,6 +449,17 @@ _PUBLIC_ enum ndr_err_code ndr_push_uint16(struct ndr_push *ndr, int ndr_flags,
        return NDR_ERR_SUCCESS;
 }
 
+/*
+  push a uint1632
+*/
+_PUBLIC_ enum ndr_err_code ndr_push_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v)
+{
+       if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
+               return ndr_push_uint32(ndr, ndr_flags, v);
+       }
+       return ndr_push_uint16(ndr, ndr_flags, v);
+}
+
 /*
   push a int32_t
 */
@@ -452,11 +492,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_uint3264(struct ndr_push *ndr, int ndr_flags
        if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
                return ndr_push_hyper(ndr, ndr_flags, v);
        }
-       NDR_PUSH_ALIGN(ndr, 4);
-       NDR_PUSH_NEED_BYTES(ndr, 4);
-       NDR_SIVAL(ndr, ndr->offset, v);
-       ndr->offset += 4;
-       return NDR_ERR_SUCCESS;
+       return ndr_push_uint32(ndr, ndr_flags, v);
 }
 
 /*
@@ -536,6 +572,12 @@ _PUBLIC_ enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size)
                } else {
                        size = 4;
                }
+       } else if (size == 3) {
+               if (ndr->flags & LIBNDR_FLAG_NDR64) {
+                       size = 4;
+               } else {
+                       size = 2;
+               }
        }
        NDR_PUSH_ALIGN(ndr, size);
        return NDR_ERR_SUCCESS;
@@ -550,11 +592,53 @@ _PUBLIC_ enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size)
                } else {
                        size = 4;
                }
+       } else if (size == 3) {
+               if (ndr->flags & LIBNDR_FLAG_NDR64) {
+                       size = 4;
+               } else {
+                       size = 2;
+               }
        }
        NDR_PULL_ALIGN(ndr, size);
        return NDR_ERR_SUCCESS;
 }
 
+_PUBLIC_ enum ndr_err_code ndr_push_union_align(struct ndr_push *ndr, size_t size)
+{
+       /* MS-RPCE section 2.2.5.3.4.4 */
+       if (ndr->flags & LIBNDR_FLAG_NDR64) {
+               return ndr_push_align(ndr, size);
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_union_align(struct ndr_pull *ndr, size_t size)
+{
+       /* MS-RPCE section 2.2.5.3.4.4 */
+       if (ndr->flags & LIBNDR_FLAG_NDR64) {
+               return ndr_pull_align(ndr, size);
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_trailer_align(struct ndr_push *ndr, size_t size)
+{
+       /* MS-RPCE section 2.2.5.3.4.1 */
+       if (ndr->flags & LIBNDR_FLAG_NDR64) {
+               return ndr_push_align(ndr, size);
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_trailer_align(struct ndr_pull *ndr, size_t size)
+{
+       /* MS-RPCE section 2.2.5.3.4.1 */
+       if (ndr->flags & LIBNDR_FLAG_NDR64) {
+               return ndr_pull_align(ndr, size);
+       }
+       return NDR_ERR_SUCCESS;
+}
+
 /*
   push some bytes
 */
@@ -806,6 +890,16 @@ _PUBLIC_ void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t
        ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
 }
 
+_PUBLIC_ void ndr_print_int3264(struct ndr_print *ndr, const char *name, int32_t v)
+{
+       ndr->print(ndr, "%-25s: %d", name, v);
+}
+
+_PUBLIC_ void ndr_print_uint3264(struct ndr_print *ndr, const char *name, uint32_t v)
+{
+       ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
+}
+
 _PUBLIC_ void ndr_print_udlong(struct ndr_print *ndr, const char *name, uint64_t v)
 {
        ndr->print(ndr, "%-25s: 0x%016llx (%llu)", name, (unsigned long long)v, (unsigned long long)v);

diff --git a/librpc/ndr/ndr_drsuapi.c b/librpc/ndr/ndr_drsuapi.c
index 0c790e52ca7a8b75f4701c02b257741b50915c8a..bfc3c75b4e704eec2b46b031a381f11c38ced306 100644 (file)
--- a/librpc/ndr/ndr_drsuapi.c
+++ b/librpc/ndr/ndr_drsuapi.c
@@ -82,102 +82,24 @@ void ndr_print_drsuapi_DsReplicaObjectListItemEx(struct ndr_print *ndr, const ch
        } \
 } while (0)
 
-enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
 {
-       if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0)));
-               NDR_CHECK(ndr_push_unique_ptr(ndr, r->oid));
-       }
-       if (ndr_flags & NDR_BUFFERS) {
-               if (r->oid) {
-                       DATA_BLOB blob;
-
-                       if (strncasecmp("ff", r->oid, 2) == 0) {
-                               blob = strhex_to_data_blob(ndr, r->oid);
-                               if (!blob.data) {
-                                       return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT,
-                                                             "HEX String Conversion Error: %s\n",
-                                                             __location__);
-                               }
-                       } else {
-                               _OID_PUSH_CHECK(ber_write_OID_String(&blob, r->oid));
-                               talloc_steal(ndr, blob.data);
-                       }
-
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, blob.length));
-                       NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, blob.data, blob.length));
-               }
-       }
-       return NDR_ERR_SUCCESS;
-}
-
-enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
-{
-       uint32_t _ptr_oid;
-       TALLOC_CTX *_mem_save_oid_0;
-       if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
-               if (r->__ndr_size < 0 || r->__ndr_size > 10000) {
-                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
-               }
-               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_oid));
-               if (_ptr_oid) {
-                       NDR_PULL_ALLOC(ndr, r->oid);
-               } else {
-                       r->oid = NULL;
-               }
-       }
-       if (ndr_flags & NDR_BUFFERS) {
-               if (r->oid) {
-                       DATA_BLOB _oid_array;
-                       const char *_oid;
-
-                       _mem_save_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
-                       NDR_PULL_SET_MEM_CTX(ndr, ndr, 0);
-                       NDR_CHECK(ndr_pull_array_size(ndr, &r->oid));
-                       _oid_array.length = ndr_get_array_size(ndr, &r->oid);
-                       NDR_PULL_ALLOC_N(ndr, _oid_array.data, _oid_array.length);
-                       NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, _oid_array.data, _oid_array.length));
-                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_oid_0, 0);
-
-                       if (_oid_array.length && _oid_array.data[0] == 0xFF) {
-                               _oid = data_blob_hex_string(ndr, &_oid_array);
-                               NDR_ERR_HAVE_NO_MEMORY(_oid);
-                       } else {
-                               _OID_PULL_CHECK(ber_read_OID_String(ndr, _oid_array, &_oid));
-                       }
-                       data_blob_free(&_oid_array);
-                       talloc_steal(r->oid, _oid);
-                       r->oid = _oid;
-               }
-               if (r->oid) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->oid, r->__ndr_size));
-               }
-       }
-       return NDR_ERR_SUCCESS;
-}
-
-size_t ndr_size_drsuapi_DsReplicaOID_oid(const char *oid, int flags)
-{
-       DATA_BLOB _blob;
-       size_t ret = 0;
-
-       if (!oid) return 0;
-
-       if (strncasecmp("ff", oid, 2) == 0) {
-               _blob = strhex_to_data_blob(NULL, oid);
-               if (_blob.data) {
-                       ret = _blob.length;
-               }
-       } else {
-               if (ber_write_OID_String(&_blob, oid)) {
-                       ret = _blob.length;
-               }
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "length", r->length);
+       ndr->print(ndr, "%-25s: length=%u", "oid", r->length);
+       if (r->binary_oid) {
+               char *partial_oid = NULL;
+               DATA_BLOB oid_blob = data_blob_const(r->binary_oid, r->length);
+               char *hex_str = data_blob_hex_string(ndr, &oid_blob);
+               ber_read_partial_OID_String(ndr, oid_blob, (const char **)&partial_oid);
+               ndr->depth++;
+               ndr->print(ndr, "%-25s: 0x%s (%s)", "binary_oid", hex_str, partial_oid);
+               ndr->depth--;
+               talloc_free(hex_str);
+               talloc_free(partial_oid);
        }
-       data_blob_free(&_blob);
-       return ret;
+       ndr->depth--;
 }
 
 enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)

diff --git a/librpc/ndr/ndr_drsuapi.h b/librpc/ndr/ndr_drsuapi.h
index 12c2c78bdea8fa1813cd5c05ca036c1f06c8b3b0..179879a3b790952603ed5e3d73d4a6123d0f676b 100644 (file)
--- a/librpc/ndr/ndr_drsuapi.h
+++ b/librpc/ndr/ndr_drsuapi.h
@@ -28,8 +28,5 @@ void ndr_print_drsuapi_DsReplicaObjectListItem(struct ndr_print *ndr, const char
 void ndr_print_drsuapi_DsReplicaObjectListItemEx(struct ndr_print *ndr, const char *name,
                                                 const struct drsuapi_DsReplicaObjectListItemEx *r);
 
-enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r);
-enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r);
-size_t ndr_size_drsuapi_DsReplicaOID_oid(const char *oid, int flags);
 
 #endif /* _LIBRPC_NDR_NDR_DRSUAPI_H */

diff --git a/nsswitch/libwbclient/tests/wbclient.c b/nsswitch/libwbclient/tests/wbclient.c
new file mode 100644 (file)
index 0000000..5a55a43
--- /dev/null
+++ b/nsswitch/libwbclient/tests/wbclient.c
@@ -0,0 +1,289 @@
+/*
+   Unix SMB/CIFS implementation.
+   SMB torture tester
+   Copyright (C) Guenther Deschner 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "nsswitch/libwbclient/wbclient.h"
+#include "torture/smbtorture.h"
+#include "torture/winbind/proto.h"
+
+#define WBC_ERROR_EQUAL(x,y) (x == y)
+
+#define torture_assert_wbc_equal(torture_ctx, got, expected, cmt) \
+       do { wbcErr __got = got, __expected = expected; \
+       if (!WBC_ERROR_EQUAL(__got, __expected)) { \
+               torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", wbcErrorString(__got), wbcErrorString(__expected), cmt); \
+               return false; \
+       } \
+       } while (0)
+
+#define torture_assert_wbc_ok(torture_ctx,expr,cmt) \
+               torture_assert_wbc_equal(torture_ctx,expr,WBC_ERR_SUCCESS,cmt)
+
+static bool test_wbc_ping(struct torture_context *tctx)
+{
+       torture_assert_wbc_ok(tctx, wbcPing(),
+               "wbcPing failed");
+
+       return true;
+}
+
+static bool test_wbc_library_details(struct torture_context *tctx)
+{
+       struct wbcLibraryDetails *details;
+
+       torture_assert_wbc_ok(tctx, wbcLibraryDetails(&details),
+               "wbcLibraryDetails failed");
+       torture_assert(tctx, details,
+               "wbcLibraryDetails returned NULL pointer");
+
+       wbcFreeMemory(details);
+
+       return true;
+}
+
+static bool test_wbc_interface_details(struct torture_context *tctx)
+{
+       struct wbcInterfaceDetails *details;
+
+       torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+               "wbcInterfaceDetails failed");
+       torture_assert(tctx, details,
+               "wbcInterfaceDetails returned NULL pointer");
+
+       wbcFreeMemory(details);
+
+       return true;
+}
+
+static bool test_wbc_sidtypestring(struct torture_context *tctx)
+{
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_USE_NONE),
+                                "SID_NONE", "SID_NONE failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_USER),
+                                "SID_USER", "SID_USER failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DOM_GRP),
+                                "SID_DOM_GROUP", "SID_DOM_GROUP failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DOMAIN),
+                                "SID_DOMAIN", "SID_DOMAIN failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_ALIAS),
+                                "SID_ALIAS", "SID_ALIAS failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_WKN_GRP),
+                                "SID_WKN_GROUP", "SID_WKN_GROUP failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DELETED),
+                                "SID_DELETED", "SID_DELETED failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_INVALID),
+                                "SID_INVALID", "SID_INVALID failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_UNKNOWN),
+                                "SID_UNKNOWN", "SID_UNKNOWN failed");
+       torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_COMPUTER),
+                                "SID_COMPUTER", "SID_COMPUTER failed");
+       return true;
+}
+
+static bool test_wbc_sidtostring(struct torture_context *tctx)
+{
+       struct wbcDomainSid sid;
+       const char *sid_string = "S-1-5-32";
+       char *sid_string2;
+
+       torture_assert_wbc_ok(tctx, wbcStringToSid(sid_string, &sid),
+               "wbcStringToSid failed");
+       torture_assert_wbc_ok(tctx, wbcSidToString(&sid, &sid_string2),
+               "wbcSidToString failed");
+       torture_assert_str_equal(tctx, sid_string, sid_string2,
+               "sid strings differ");
+
+       return true;
+}
+
+static bool test_wbc_guidtostring(struct torture_context *tctx)
+{
+       struct wbcGuid guid;
+       const char *guid_string = "f7cf07b4-1487-45c7-824d-8b18cc580811";
+       char *guid_string2;
+
+       torture_assert_wbc_ok(tctx, wbcStringToGuid(guid_string, &guid),
+               "wbcStringToGuid failed");
+       torture_assert_wbc_ok(tctx, wbcGuidToString(&guid, &guid_string2),
+               "wbcGuidToString failed");
+       torture_assert_str_equal(tctx, guid_string, guid_string2,
+               "guid strings differ");
+
+       return true;
+}
+
+static bool test_wbc_domain_info(struct torture_context *tctx)
+{
+       const char *domain_name = NULL;
+       struct wbcDomainInfo *info;
+       struct wbcInterfaceDetails *details;
+
+       torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+               "wbcInterfaceDetails failed");
+
+       domain_name = talloc_strdup(tctx, details->netbios_domain);
+       wbcFreeMemory(details);
+
+       torture_assert_wbc_ok(tctx, wbcDomainInfo(domain_name, &info),
+               "wbcDomainInfo failed");
+       torture_assert(tctx, info,
+               "wbcDomainInfo returned NULL pointer");
+
+       return true;
+}
+
+static bool test_wbc_users(struct torture_context *tctx)
+{
+       const char *domain_name = NULL;
+       uint32_t num_users;
+       const char **users;
+       int i;
+       struct wbcInterfaceDetails *details;
+
+       torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+               "wbcInterfaceDetails failed");
+
+       domain_name = talloc_strdup(tctx, details->netbios_domain);
+       wbcFreeMemory(details);
+
+       torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
+               "wbcListUsers failed");
+       torture_assert(tctx, !(num_users > 0 && !users),
+               "wbcListUsers returned invalid results");
+
+       for (i=0; i < MIN(num_users,100); i++) {
+
+               struct wbcDomainSid sid, *sids;
+               enum wbcSidType name_type;
+               char *domain;
+               char *name;
+               uint32_t num_sids;
+
+               torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, users[i], &sid, &name_type),
+                       "wbcLookupName failed");
+               torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
+                       "wbcLookupName expected WBC_SID_NAME_USER");
+               torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
+                       "wbcLookupSid failed");
+               torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
+                       "wbcLookupSid expected WBC_SID_NAME_USER");
+               torture_assert(tctx, name,
+                       "wbcLookupSid returned no name");
+               torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
+                       "wbcLookupUserSids failed");
+       }
+
+       return true;
+}
+
+static bool test_wbc_groups(struct torture_context *tctx)
+{
+       const char *domain_name = NULL;
+       uint32_t num_groups;
+       const char **groups;
+       int i;
+       struct wbcInterfaceDetails *details;
+
+       torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+               "wbcInterfaceDetails failed");
+
+       domain_name = talloc_strdup(tctx, details->netbios_domain);
+       wbcFreeMemory(details);
+
+       torture_assert_wbc_ok(tctx, wbcListGroups(domain_name, &num_groups, &groups),
+               "wbcListGroups failed");
+       torture_assert(tctx, !(num_groups > 0 && !groups),
+               "wbcListGroups returned invalid results");
+
+       for (i=0; i < MIN(num_groups,100); i++) {
+
+               struct wbcDomainSid sid;
+               enum wbcSidType name_type;
+               char *domain;
+               char *name;
+
+               torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, groups[i], &sid, &name_type),
+                       "wbcLookupName failed");
+               torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
+                       "wbcLookupSid failed");
+               torture_assert(tctx, name,
+                       "wbcLookupSid returned no name");
+       }
+
+       return true;
+}
+
+static bool test_wbc_trusts(struct torture_context *tctx)
+{
+       struct wbcDomainInfo *domains;
+       size_t num_domains;
+       int i;
+
+       torture_assert_wbc_ok(tctx, wbcListTrusts(&domains, &num_domains),
+               "wbcListTrusts failed");
+       torture_assert(tctx, !(num_domains > 0 && !domains),
+               "wbcListTrusts returned invalid results");
+
+       for (i=0; i < MIN(num_domains,100); i++) {
+
+               struct wbcAuthErrorInfo *error;
+               /*
+               struct wbcDomainSid sid;
+               enum wbcSidType name_type;
+               char *domain;
+               char *name;
+               */
+               torture_assert_wbc_ok(tctx, wbcCheckTrustCredentials(domains[i].short_name, &error),
+                       "wbcCheckTrustCredentials failed");
+               /*
+               torture_assert_wbc_ok(tctx, wbcLookupName(domains[i].short_name, NULL, &sid, &name_type),
+                       "wbcLookupName failed");
+               torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
+                       "wbcLookupName expected WBC_SID_NAME_DOMAIN");
+               torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
+                       "wbcLookupSid failed");
+               torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
+                       "wbcLookupSid expected WBC_SID_NAME_DOMAIN");
+               torture_assert(tctx, name,
+                       "wbcLookupSid returned no name");
+               */
+       }
+
+       return true;
+}
+
+
+
+struct torture_suite *torture_wbclient(void)
+{
+       struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "WBCLIENT");
+
+       torture_suite_add_simple_test(suite, "wbcPing", test_wbc_ping);
+       torture_suite_add_simple_test(suite, "wbcLibraryDetails", test_wbc_library_details);
+       torture_suite_add_simple_test(suite, "wbcInterfaceDetails", test_wbc_interface_details);
+       torture_suite_add_simple_test(suite, "wbcSidTypeString", test_wbc_sidtypestring);
+       torture_suite_add_simple_test(suite, "wbcSidToString", test_wbc_sidtostring);
+       torture_suite_add_simple_test(suite, "wbcGuidToString", test_wbc_guidtostring);
+       torture_suite_add_simple_test(suite, "wbcDomainInfo", test_wbc_domain_info);
+       torture_suite_add_simple_test(suite, "wbcListUsers", test_wbc_users);
+       torture_suite_add_simple_test(suite, "wbcListGroups", test_wbc_groups);
+       torture_suite_add_simple_test(suite, "wbcListTrusts", test_wbc_trusts);
+
+       return suite;
+}

diff --git a/nsswitch/libwbclient/wbc_pam.c b/nsswitch/libwbclient/wbc_pam.c
index 33044b2df74f7a0df1abf0bf7fb6b34d0be3b72c..7a66a7fe82675c538bd058981b1b5c1875bfb49d 100644 (file)
--- a/nsswitch/libwbclient/wbc_pam.c
+++ b/nsswitch/libwbclient/wbc_pam.c
@@ -502,21 +502,55 @@ wbcErr wbcCheckTrustCredentials(const char *domain,
        struct winbindd_response response;
        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 
+       ZERO_STRUCT(request);
+       ZERO_STRUCT(response);
+
        if (domain) {
-               /*
-                * the current protocol doesn't support
-                * specifying a domain
-                */
-               wbc_status = WBC_ERR_NOT_IMPLEMENTED;
+               strncpy(request.domain_name, domain,
+                       sizeof(request.domain_name)-1);
+       }
+
+       /* Send request */
+
+       wbc_status = wbcRequestResponse(WINBINDD_CHECK_MACHACC,
+                                       &request,
+                                       &response);
+       if (response.data.auth.nt_status != 0) {
+               if (error) {
+                       wbc_status = wbc_create_error_info(NULL,
+                                                          &response,
+                                                          error);
+                       BAIL_ON_WBC_ERROR(wbc_status);
+               }
+
+               wbc_status = WBC_ERR_AUTH_ERROR;
                BAIL_ON_WBC_ERROR(wbc_status);
        }
+       BAIL_ON_WBC_ERROR(wbc_status);
+
+ done:
+       return wbc_status;
+}
+
+/* Trigger a change of the trust credentials for a specific domain */
+wbcErr wbcChangeTrustCredentials(const char *domain,
+                                struct wbcAuthErrorInfo **error)
+{
+       struct winbindd_request request;
+       struct winbindd_response response;
+       wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 
        ZERO_STRUCT(request);
        ZERO_STRUCT(response);
 
+       if (domain) {
+               strncpy(request.domain_name, domain,
+                       sizeof(request.domain_name)-1);
+       }
+
        /* Send request */
 
-       wbc_status = wbcRequestResponse(WINBINDD_CHECK_MACHACC,
+       wbc_status = wbcRequestResponse(WINBINDD_CHANGE_MACHACC,
                                        &request,
                                        &response);
        if (response.data.auth.nt_status != 0) {

diff --git a/nsswitch/libwbclient/wbc_sid.c b/nsswitch/libwbclient/wbc_sid.c
index b1ecba3f6d2d121ec5eddf419aabb6bbcb3b3144..99c9d8e1521fa9cd7c51fcddf5b8a2d4fd8342bf 100644 (file)
--- a/nsswitch/libwbclient/wbc_sid.c
+++ b/nsswitch/libwbclient/wbc_sid.c
@@ -248,9 +248,13 @@ wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
        if (WBC_ERROR_IS_OK(wbc_status)) {
                if (pdomain != NULL) {
                        *pdomain = domain;
+               } else {
+                       TALLOC_FREE(domain);
                }
                if (pname != NULL) {
                        *pname = name;
+               } else {
+                       TALLOC_FREE(name);
                }
                if (pname_type != NULL) {
                        *pname_type = name_type;

diff --git a/nsswitch/libwbclient/wbclient.c b/nsswitch/libwbclient/wbclient.c
index f4620ff0025832cfa131fdd043f320eaacca3c9d..9a1e770690e736c78d746c6a153b296c04a1c602 100644 (file)
--- a/nsswitch/libwbclient/wbclient.c
+++ b/nsswitch/libwbclient/wbclient.c
@@ -23,8 +23,8 @@
 /* Required Headers */
 
 #include "replace.h"
-#include "lib/talloc/talloc.h"
-#include "lib/tevent/tevent.h"
+#include "talloc.h"
+#include "tevent.h"
 #include "libwbclient.h"
 
 /* From wb_common.c */

diff --git a/nsswitch/libwbclient/wbclient.h b/nsswitch/libwbclient/wbclient.h
index a87cad3b219667f958b3937bbd1a2379af9f4973..eea71ab86bedfd8b8c3f91a1b55b8af4d04a40f6 100644 (file)
--- a/nsswitch/libwbclient/wbclient.h
+++ b/nsswitch/libwbclient/wbclient.h
@@ -63,9 +63,10 @@ const char *wbcErrorString(wbcErr error);
  *  0.3: Added wbcGetpwsid()
  *      Added wbcGetSidAliases()
  *  0.4: Added wbcSidTypeString()
+ *  0.5: Added wbcChangeTrustCredentials()
  **/
 #define WBCLIENT_MAJOR_VERSION 0
-#define WBCLIENT_MINOR_VERSION 4
+#define WBCLIENT_MINOR_VERSION 5
 #define WBCLIENT_VENDOR_VERSION "Samba libwbclient"
 struct wbcLibraryDetails {
        uint16_t major_version;
@@ -427,12 +428,23 @@ struct wbcUserPasswordPolicyInfo {
  **/
 
 enum wbcPasswordChangeRejectReason {
-       WBC_PWD_CHANGE_REJECT_OTHER=0,
-       WBC_PWD_CHANGE_REJECT_TOO_SHORT=1,
-       WBC_PWD_CHANGE_REJECT_IN_HISTORY=2,
-       WBC_PWD_CHANGE_REJECT_COMPLEXITY=5
+       WBC_PWD_CHANGE_NO_ERROR=0,
+       WBC_PWD_CHANGE_PASSWORD_TOO_SHORT=1,
+       WBC_PWD_CHANGE_PWD_IN_HISTORY=2,
+       WBC_PWD_CHANGE_USERNAME_IN_PASSWORD=3,
+       WBC_PWD_CHANGE_FULLNAME_IN_PASSWORD=4,
+       WBC_PWD_CHANGE_NOT_COMPLEX=5,
+       WBC_PWD_CHANGE_MACHINE_NOT_DEFAULT=6,
+       WBC_PWD_CHANGE_FAILED_BY_FILTER=7,
+       WBC_PWD_CHANGE_PASSWORD_TOO_LONG=8
 };
 
+/* Note: this defines exist for compatibility reasons with existing code */
+#define WBC_PWD_CHANGE_REJECT_OTHER      WBC_PWD_CHANGE_NO_ERROR
+#define WBC_PWD_CHANGE_REJECT_TOO_SHORT  WBC_PWD_CHANGE_PASSWORD_TOO_SHORT
+#define WBC_PWD_CHANGE_REJECT_IN_HISTORY WBC_PWD_CHANGE_PWD_IN_HISTORY
+#define WBC_PWD_CHANGE_REJECT_COMPLEXITY WBC_PWD_CHANGE_NOT_COMPLEX
+
 /**
  * @brief Logoff User Parameters
  **/
@@ -1183,9 +1195,7 @@ wbcErr wbcResolveWinsByIP(const char *ip, char **name);
 /**
  * @brief Trigger a verification of the trust credentials of a specific domain
  *
- * @param *domain      The name of the domain, only NULL for the default domain is
- *                     supported yet. Other values than NULL will result in
- *                     WBC_ERR_NOT_IMPLEMENTED.
+ * @param *domain      The name of the domain.
  * @param error        Output details on WBC_ERR_AUTH_ERROR
  *
  * @return #wbcErr
@@ -1193,6 +1203,17 @@ wbcErr wbcResolveWinsByIP(const char *ip, char **name);
 wbcErr wbcCheckTrustCredentials(const char *domain,
                                struct wbcAuthErrorInfo **error);
 
+/**
+ * @brief Trigger a change of the trust credentials for a specific domain
+ *
+ * @param *domain      The name of the domain.
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcChangeTrustCredentials(const char *domain,
+                                struct wbcAuthErrorInfo **error);
+
 /**********************************************************
  * Helper functions
  **********************************************************/

diff --git a/nsswitch/pam_winbind.c b/nsswitch/pam_winbind.c
index 324bede9ea38ec3854c050cdc80081dde059755f..fdb5be32238187b37953805da254d766bc432b0b 100644 (file)
--- a/nsswitch/pam_winbind.c
+++ b/nsswitch/pam_winbind.c
@@ -980,7 +980,8 @@ static bool winbind_name_to_sid_string(struct pwb_context *ctx,
                                       char *sid_list_buffer,
                                       int sid_list_buffer_size)
 {
-       const char* sid_string;
+       const char* sid_string = NULL;
+       char *sid_str = NULL;
 
        /* lookup name? */
        if (IS_SID_STRING(name)) {
@@ -989,7 +990,6 @@ static bool winbind_name_to_sid_string(struct pwb_context *ctx,
                wbcErr wbc_status;
                struct wbcDomainSid sid;
                enum wbcSidType type;
-               char *sid_str;
 
                _pam_log_debug(ctx, LOG_DEBUG,
                               "no sid given, looking up: %s\n", name);
@@ -1006,15 +1006,16 @@ static bool winbind_name_to_sid_string(struct pwb_context *ctx,
                        return false;
                }
 
-               wbcFreeMemory(sid_str);
                sid_string = sid_str;
        }
 
        if (!safe_append_string(sid_list_buffer, sid_string,
                                sid_list_buffer_size)) {
+               wbcFreeMemory(sid_str);
                return false;
        }
 
+       wbcFreeMemory(sid_str);
        return true;
 }
 
@@ -1862,22 +1863,22 @@ static int winbind_chauthtok_request(struct pwb_context *ctx,
                switch (reject_reason) {
                        case -1:
                                break;
-                       case WBC_PWD_CHANGE_REJECT_OTHER:
+                       case WBC_PWD_CHANGE_NO_ERROR:
                                if ((min_pwd_age > 0) &&
                                    (pwd_last_set + min_pwd_age > time(NULL))) {
                                        PAM_WB_REMARK_DIRECT(ctx,
                                             "NT_STATUS_PWD_TOO_RECENT");
                                }
                                break;
-                       case WBC_PWD_CHANGE_REJECT_TOO_SHORT:
+                       case WBC_PWD_CHANGE_PASSWORD_TOO_SHORT:
                                PAM_WB_REMARK_DIRECT(ctx,
                                        "NT_STATUS_PWD_TOO_SHORT");
                                break;
-                       case WBC_PWD_CHANGE_REJECT_IN_HISTORY:
+                       case WBC_PWD_CHANGE_PWD_IN_HISTORY:
                                PAM_WB_REMARK_DIRECT(ctx,
                                        "NT_STATUS_PWD_HISTORY_CONFLICT");
                                break;
-                       case WBC_PWD_CHANGE_REJECT_COMPLEXITY:
+                       case WBC_PWD_CHANGE_NOT_COMPLEX:
                                _make_remark(ctx, PAM_ERROR_MSG,
                                             _("Password does not meet "
                                               "complexity requirements"));

diff --git a/nsswitch/wbinfo.c b/nsswitch/wbinfo.c
index a80b69f2b6bcb05e529e82f04e5c0355c3898745..219ec24fbaa72f4777695a7022a916b5b03eda23 100644 (file)
--- a/nsswitch/wbinfo.c
+++ b/nsswitch/wbinfo.c
@@ -724,15 +724,55 @@ static bool wbinfo_dsgetdcname(const char *domain_name, uint32_t flags)
 
 /* Check trust account password */
 
-static bool wbinfo_check_secret(void)
+static bool wbinfo_check_secret(const char *domain)
 {
        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
        struct wbcAuthErrorInfo *error = NULL;
+       const char *domain_name;
 
-       wbc_status = wbcCheckTrustCredentials(NULL, &error);
+       if (domain) {
+               domain_name = domain;
+       } else {
+               domain_name = get_winbind_domain();
+       }
 
-       d_printf("checking the trust secret via RPC calls %s\n",
-                WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
+       wbc_status = wbcCheckTrustCredentials(domain_name, &error);
+
+       d_printf("checking the trust secret for domain %s via RPC calls %s\n",
+               domain_name,
+               WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
+
+       if (wbc_status == WBC_ERR_AUTH_ERROR) {
+               d_fprintf(stderr, "error code was %s (0x%x)\n",
+                         error->nt_string, error->nt_status);
+               wbcFreeMemory(error);
+       }
+       if (!WBC_ERROR_IS_OK(wbc_status)) {
+               return false;
+       }
+
+       return true;
+}
+
+/* Change trust account password */
+
+static bool wbinfo_change_secret(const char *domain)
+{
+       wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+       struct wbcAuthErrorInfo *error = NULL;
+       const char *domain_name;
+
+       if (domain) {
+               domain_name = domain;
+       } else {
+               domain_name = get_winbind_domain();
+       }
+
+       wbc_status = wbcChangeTrustCredentials(domain_name, &error);
+
+       d_printf("changing the trust secret for domain %s via RPC calls %s\n",
+               domain_name,
+               WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
 
        if (wbc_status == WBC_ERR_AUTH_ERROR) {
                d_fprintf(stderr, "error code was %s (0x%x)\n",
@@ -1725,6 +1765,7 @@ int main(int argc, char **argv, char **envp)
                { "remove-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_UID_MAPPING, "Remove uid to sid mapping in idmap", "UID,SID" },
                { "remove-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_GID_MAPPING, "Remove gid to sid mapping in idmap", "GID,SID" },
                { "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
+               { "change-secret", 'c', POPT_ARG_NONE, 0, 'c', "Change shared secret" },
                { "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
                { "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
                { "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
@@ -1950,11 +1991,17 @@ int main(int argc, char **argv, char **envp)
                        }
                        break;
                case 't':
-                       if (!wbinfo_check_secret()) {
+                       if (!wbinfo_check_secret(opt_domain_name)) {
                                d_fprintf(stderr, "Could not check secret\n");
                                goto done;
                        }
                        break;
+               case 'c':
+                       if (!wbinfo_change_secret(opt_domain_name)) {
+                               d_fprintf(stderr, "Could not change secret\n");
+                               goto done;
+                       }
+                       break;
                case 'm':
                        if (!wbinfo_list_domains(false, verbose)) {
                                d_fprintf(stderr,

diff --git a/nsswitch/winbind_struct_protocol.h b/nsswitch/winbind_struct_protocol.h
index bd144101f2449a5c6c345c4928ff8ce41df77dff..3056e25905e49bc1a0abb35072e9343a31775a7a 100644 (file)
--- a/nsswitch/winbind_struct_protocol.h
+++ b/nsswitch/winbind_struct_protocol.h
@@ -118,6 +118,7 @@ enum winbindd_cmd {
        /* Miscellaneous other stuff */
 
        WINBINDD_CHECK_MACHACC,     /* Check machine account pw works */
+       WINBINDD_CHANGE_MACHACC,    /* Change machine account pw */
        WINBINDD_PING,              /* Just tell me winbind is running */
        WINBINDD_INFO,              /* Various bit of info.  Currently just tidbits */
        WINBINDD_DOMAIN_NAME,       /* The domain this winbind server is a member of (lp_workgroup()) */

diff --git a/packaging/RHEL/makerpms.sh.tmpl b/packaging/RHEL/makerpms.sh.tmpl
index 5b377bda575d2686157a3c080fa72ed59949ae6d..93d2d82692c8509014626c2892a69ac0f77d6c41 100644 (file)
--- a/packaging/RHEL/makerpms.sh.tmpl
+++ b/packaging/RHEL/makerpms.sh.tmpl
@@ -40,8 +40,8 @@ case $RPMVER in
 esac
 
 pushd .
-cd ../../source
-if [ -f Makefile ]; then 
+cd ../../source3
+if [ -f Makefile ]; then
        make distclean
 fi
 popd

diff --git a/packaging/RHEL/samba.spec.tmpl b/packaging/RHEL/samba.spec.tmpl
index 15deecd75a863e193f48a036095e70174b11c63e..4d27b1a9a8305dd8264eb372257e768c29a48e86 100644 (file)
--- a/packaging/RHEL/samba.spec.tmpl
+++ b/packaging/RHEL/samba.spec.tmpl
@@ -174,8 +174,7 @@ if [ ${CC_MAJOR} -ge 3 ]; then
 fi
 
 
-make CFLAGS="$RPM_OPT_FLAGS -D_GNU_SOURCE" %{?_smp_mflags} \
-       all modules pam_smbpass
+make all modules pam_smbpass
 
 # Remove some permission bits to avoid to many dependencies
 cd ..
@@ -210,8 +209,8 @@ make DESTDIR=$RPM_BUILD_ROOT \
 cd ..
 
 # NSS winbind support
-install -m 755 source3/nsswitch/libnss_winbind.so $RPM_BUILD_ROOT/%{_libarch}/libnss_winbind.so.2
-install -m 755 source3/nsswitch/libnss_wins.so $RPM_BUILD_ROOT/%{_libarch}/libnss_wins.so.2
+install -m 755 nsswitch/libnss_winbind.so $RPM_BUILD_ROOT/%{_libarch}/libnss_winbind.so.2
+install -m 755 nsswitch/libnss_wins.so $RPM_BUILD_ROOT/%{_libarch}/libnss_wins.so.2
 ( cd $RPM_BUILD_ROOT/%{_libarch};
   ln -sf libnss_winbind.so.2  libnss_winbind.so;
   ln -sf libnss_wins.so.2  libnss_wins.so )
@@ -440,6 +439,24 @@ fi
 %attr(755,root,root) /%{_libarch}/security/pam_winbind.so
 %attr(755,root,root) /%{_libarch}/security/pam_smbpass.so
 /usr/share/locale/de/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/ar/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/cs/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/da/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/es/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/fi/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/fr/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/hu/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/it/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/ja/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/ko/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/nb/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/nl/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/pl/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/pt_BR/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/ru/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/sv/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/zh_CN/LC_MESSAGES/pam_winbind.mo
+/usr/share/locale/zh_TW/LC_MESSAGES/pam_winbind.mo
 
 %{_includedir}/libsmbclient.h
 %{_libarchdir}/libsmbclient.*

diff --git a/pidl/lib/Parse/Pidl/NDR.pm b/pidl/lib/Parse/Pidl/NDR.pm
index 7aebed0fe2429fb150d7219005b1f9dbf72faef3..4e680b336f1bdf4646c31ca46f6883bdec4919a7 100644 (file)
--- a/pidl/lib/Parse/Pidl/NDR.pm
+++ b/pidl/lib/Parse/Pidl/NDR.pm
@@ -39,7 +39,7 @@ $VERSION = '0.01';
 
 use strict;
 use Parse::Pidl qw(warning fatal);
-use Parse::Pidl::Typelist qw(hasType getType expandAlias);
+use Parse::Pidl::Typelist qw(hasType getType expandAlias mapScalarType);
 use Parse::Pidl::Util qw(has_property property_matches);
 
 # Alignment of the built-in scalar types
@@ -50,8 +50,12 @@ my $scalar_alignment = {
        'uint8' => 1,
        'int16' => 2,
        'uint16' => 2,
+       'int1632' => 3,
+       'uint1632' => 3,
        'int32' => 4,
        'uint32' => 4,
+       'int3264' => 5,
+       'uint3264' => 5,
        'hyper' => 8,
        'double' => 8,
        'pointer' => 8,
@@ -404,6 +408,8 @@ sub align_type($)
 
        if ($dt->{TYPE} eq "TYPEDEF") {
                return align_type($dt->{DATA});
+       } elsif ($dt->{TYPE} eq "CONFORMANCE") {
+               return $dt->{DATA}->{ALIGN};
        } elsif ($dt->{TYPE} eq "ENUM") {
                return align_type(Parse::Pidl::Typelist::enum_type_fn($dt));
        } elsif ($dt->{TYPE} eq "BITMAP") {
@@ -509,7 +515,8 @@ sub ParseUnion($$)
                ELEMENTS => undef,
                PROPERTIES => $e->{PROPERTIES},
                HAS_DEFAULT => $hasdefault,
-               ORIGINAL => $e
+               ORIGINAL => $e,
+               ALIGN => undef
        } unless defined($e->{ELEMENTS});
 
        CheckPointerTypes($e, $pointer_default);
@@ -533,6 +540,11 @@ sub ParseUnion($$)
                push @elements, $t;
        }
 
+       my $align = undef;
+       if ($e->{NAME}) {
+               $align = align_type($e->{NAME});
+       }
+
        return {
                TYPE => "UNION",
                NAME => $e->{NAME},
@@ -540,7 +552,8 @@ sub ParseUnion($$)
                ELEMENTS => \@elements,
                PROPERTIES => $e->{PROPERTIES},
                HAS_DEFAULT => $hasdefault,
-               ORIGINAL => $e
+               ORIGINAL => $e,
+               ALIGN => $align
        };
 }
 
@@ -997,13 +1010,13 @@ sub ValidElement($)
                        my $discriminator_type = has_property($type->{DATA}, "switch_type");
                        $discriminator_type = "uint32" unless defined ($discriminator_type);
 
-                       my $t1 = mapToScalar($discriminator_type);
+                       my $t1 = mapScalarType(mapToScalar($discriminator_type));
 
                        if (not defined($t1)) {
                                fatal($e, el_name($e) . ": unable to map discriminator type '$discriminator_type' to scalar");
                        }
 
-                       my $t2 = mapToScalar($e2->{TYPE});
+                       my $t2 = mapScalarType(mapToScalar($e2->{TYPE}));
                        if (not defined($t2)) {
                                fatal($e, el_name($e) . ": unable to map variable used for switch_is() to scalar");
                        }

diff --git a/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
index 62e38bf7e981e05ef0c271409cc1144f7e858cb2..11a43b4509dc8b762a1e78b7c3e63fd0aed59163 100644 (file)
--- a/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
+++ b/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
@@ -1235,6 +1235,8 @@ sub ParseStructPushPrimitives($$$$$)
        }
 
        $self->ParseElementPush($_, $ndr, $env, 1, 0) foreach (@{$struct->{ELEMENTS}});
+
+       $self->pidl("NDR_CHECK(ndr_push_trailer_align($ndr, $struct->{ALIGN}));");
 }
 
 sub ParseStructPushDeferred($$$$)
@@ -1533,6 +1535,8 @@ sub ParseStructPullPrimitives($$$$$)
        $self->ParseElementPull($_, $ndr, $env, 1, 0) foreach (@{$struct->{ELEMENTS}});
 
        $self->add_deferred();
+
+       $self->pidl("NDR_CHECK(ndr_pull_trailer_align($ndr, $struct->{ALIGN}));");
 }
 
 sub ParseStructPullDeferred($$$$$)
@@ -1644,6 +1648,10 @@ sub ParseUnionPushPrimitives($$$$)
                $self->pidl("NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}($ndr, NDR_SCALARS, level));");
        }
 
+       if (defined($e->{ALIGN})) {
+               $self->pidl("NDR_CHECK(ndr_push_union_align($ndr, $e->{ALIGN}));");
+       }
+
        $self->pidl("switch (level) {");
        $self->indent;
        foreach my $el (@{$e->{ELEMENTS}}) {
@@ -1788,6 +1796,10 @@ sub ParseUnionPullPrimitives($$$$$)
                $self->pidl("}");
        }
 
+       if (defined($e->{ALIGN})) {
+               $self->pidl("NDR_CHECK(ndr_pull_union_align($ndr, $e->{ALIGN}));");
+       }
+
        $self->pidl("switch (level) {");
        $self->indent;
        foreach my $el (@{$e->{ELEMENTS}}) {

diff --git a/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/pidl/lib/Parse/Pidl/Samba4/TDR.pm
index a6b74a0ba45d0d51265ae832d7ca9d82113ea577..c0749304ef32a11b96ff357c2b0fd1f00141e245 100644 (file)
--- a/pidl/lib/Parse/Pidl/Samba4/TDR.pm
+++ b/pidl/lib/Parse/Pidl/Samba4/TDR.pm
@@ -7,6 +7,7 @@ package Parse::Pidl::Samba4::TDR;
 use Parse::Pidl qw(fatal);
 use Parse::Pidl::Util qw(has_property ParseExpr is_constant);
 use Parse::Pidl::Samba4 qw(is_intree choose_header);
+use Parse::Pidl::Typelist qw(mapTypeName);
 
 use Exporter;
 @ISA = qw(Exporter);
@@ -195,15 +196,16 @@ sub ParserEnum($$$$)
 {
        my ($self,$e,$t,$p) = @_;
        my $bt = Parse::Pidl::Typelist::enum_type_fn($e);
+       my $mt = mapTypeName($bt);
 
        $self->fn_declare($p, "NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", enum $e->{NAME} *v)");
        $self->pidl("{");
        if ($t eq "pull") {
-               $self->pidl("\t$bt\_t r;");
+               $self->pidl("\t$mt r;");
                $self->pidl("\tTDR_CHECK(tdr_$t\_$bt(tdr, mem_ctx, \&r));");
                $self->pidl("\t*v = r;");
        } elsif ($t eq "push") {
-               $self->pidl("\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));");
+               $self->pidl("\tTDR_CHECK(tdr_$t\_$bt(tdr, ($mt *)v));");
        } elsif ($t eq "print") {
                $self->pidl("\t/* FIXME */");
        }

diff --git a/pidl/lib/Parse/Pidl/Typelist.pm b/pidl/lib/Parse/Pidl/Typelist.pm
index 12ffa92bf6ff795d61701455f7e75dd76baa47e6..1d82dee833287de4625f0c6f6dbc2673ba3f589c 100644 (file)
--- a/pidl/lib/Parse/Pidl/Typelist.pm
+++ b/pidl/lib/Parse/Pidl/Typelist.pm
@@ -32,8 +32,12 @@ my %scalars = (
        "uint8"         => "uint8_t",
        "int16"         => "int16_t",
        "uint16"        => "uint16_t",
+       "int1632"       => "int16_t",
+       "uint1632"      => "uint16_t",
        "int32"         => "int32_t",
        "uint32"        => "uint32_t",
+       "int3264"       => "int32_t",
+       "uint3264"      => "uint32_t",
        "hyper"         => "uint64_t",
        "dlong"         => "int64_t",
        "udlong"        => "uint64_t",
@@ -220,7 +224,7 @@ sub enum_type_fn($)
        } elsif (has_property($enum->{PARENT}, "v1_enum")) {
                return "uint32";
        }
-       return "uint16";
+       return "uint1632";
 }
 
 sub bitmap_type_fn($)

diff --git a/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm
index 5c37b4a0c4f8eab2f02851e896d85c7f86ab0c92..1dec647d87d19886f207584c00a6ed690d0ee351 100644 (file)
--- a/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm
+++ b/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm
@@ -110,6 +110,7 @@ use strict;
 
 use Parse::Pidl qw(fatal warning error);
 use Parse::Pidl::Util qw(has_property);
+use Parse::Pidl::Typelist qw(addType);
 
 sub handle_type($$$$$$$$$$)
 {
@@ -149,6 +150,17 @@ sub handle_type($$$$$$$$$$)
                VALSSTRING => $valsstring,
                ALIGNMENT => $alignment
        };
+
+       addType({
+               NAME => $name,
+               TYPE => "CONFORMANCE",
+               BASEFILE => "conformance file",
+               DATA => {
+                       NAME => $name,
+                       TYPE => "CONFORMANCE",
+                       ALIGN => $alignment
+               }
+       });
 }
 
 sub handle_tfs($$$$$)

diff --git a/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/pidl/lib/Parse/Pidl/Wireshark/NDR.pm
index a9ad555cca4acfe442c1a6906547308109e75bca..b8adf2dc4eb16d520587a39ae1b93ff1a12560f2 100644 (file)
--- a/pidl/lib/Parse/Pidl/Wireshark/NDR.pm
+++ b/pidl/lib/Parse/Pidl/Wireshark/NDR.pm
@@ -1,5 +1,5 @@
 ##################################################
-# Samba4 NDR parser generator for IDL structures
+# Wireshark NDR parser generator for IDL structures
 # Copyright tridge@samba.org 2000-2003
 # Copyright tpot@samba.org 2001,2005
 # Copyright jelmer@samba.org 2004-2007
@@ -545,6 +545,9 @@ sub Struct($$$$)
        $self->indent;
        $self->pidl_code("proto_item *item = NULL;");
        $self->pidl_code("proto_tree *tree = NULL;");
+       if ($e->{ALIGN} > 1) {
+               $self->pidl_code("dcerpc_info *di = pinfo->private_data;");
+       }
        $self->pidl_code("int old_offset;");
        $self->pidl_code("");
 
@@ -565,6 +568,15 @@ sub Struct($$$$)
        $self->pidl_code("\n$res");
 
        $self->pidl_code("proto_item_set_len(item, offset-old_offset);\n");
+       if ($e->{ALIGN} > 1) {
+               $self->pidl_code("");
+               $self->pidl_code("if (di->call_data->flags & DCERPC_IS_NDR64) {");
+               $self->indent;
+               $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;");
+               $self->deindent;
+               $self->pidl_code("}");
+       }
+       $self->pidl_code("");
        $self->pidl_code("return offset;");
        $self->deindent;
        $self->pidl_code("}\n");
@@ -634,6 +646,8 @@ sub Union($$$$)
 
        $self->pidl_code("switch(level) {$res\t}");
        $self->pidl_code("proto_item_set_len(item, offset-old_offset);\n");
+       $self->pidl_code("");
+
        $self->pidl_code("return offset;");
        $self->deindent;
        $self->pidl_code("}");
@@ -895,7 +909,7 @@ sub Initialize($$)
 sub Parse($$$$$)
 {
        my($self,$ndr,$idl_file,$h_filename,$cnf_file) = @_;
-       
+
        $self->Initialize($cnf_file);
 
        return (undef, undef) if defined($self->{conformance}->{noemit_dissector});

diff --git a/pidl/pidl b/pidl/pidl
index bc0bb3524bd68eda8d88cc3af516fcdf88b0188d..d0623a06904a7491ea8e9828bb6ebb583debe92f 100755 (executable)
--- a/pidl/pidl
+++ b/pidl/pidl
@@ -653,7 +653,18 @@ sub process_file($)
 
        $pidl = Parse::Pidl::ODL::ODL2IDL($pidl, dirname($idl_file), \@opt_incdirs);
 
-       if (defined($opt_ws_parser) or 
+       if (defined($opt_ws_parser)) {
+         require Parse::Pidl::Wireshark::NDR;
+
+         my $cnffile = $idl_file;
+         $cnffile =~ s/\.idl$/\.cnf/;
+
+         my $generator = new Parse::Pidl::Wireshark::NDR();
+         $generator->Initialize($cnffile);
+       }
+
+
+       if (defined($opt_ws_parser) or
            defined($opt_client) or
            defined($opt_server) or 
            defined($opt_header) or

diff --git a/pidl/tests/ndr.pl b/pidl/tests/ndr.pl
index 53b8cb89e3b47834c8f85eaf2c859fb5b218838d..9c301892ae20a34b3102b447bbea9c63961f1cb9 100755 (executable)
--- a/pidl/tests/ndr.pl
+++ b/pidl/tests/ndr.pl
@@ -533,7 +533,8 @@ $t = {
        ORIGINAL => {
                TYPE => "UNION",
                NAME => "foo"
-       }
+       },
+       ALIGN => undef
 };
 is_deeply(ParseType($t->{ORIGINAL}, "ref"), $t); 
 

diff --git a/pidl/tests/samba-ndr.pl b/pidl/tests/samba-ndr.pl
index 5c9c6afd8511194ae69fe68151141f86a2656b1a..e2578178099f21ca73ba73705e9d5b6707508ff2 100755 (executable)
--- a/pidl/tests/samba-ndr.pl
+++ b/pidl/tests/samba-ndr.pl
@@ -223,6 +223,7 @@ $generator->ParseStructPush({
                        ELEMENTS => [ ]}, "ndr", "x");
 is($generator->{res}, "if (ndr_flags & NDR_SCALARS) {
        NDR_CHECK(ndr_push_align(ndr, 4));
+       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 }
 if (ndr_flags & NDR_BUFFERS) {
 }
@@ -248,6 +249,7 @@ is($generator->{res}, "if (ndr_flags & NDR_SCALARS) {
        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_string_array_size(ndr, x->el1)));
        NDR_CHECK(ndr_push_align(ndr, 4));
        NDR_CHECK(ndr_push_mytype(ndr, NDR_SCALARS, &x->el1));
+       NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 }
 if (ndr_flags & NDR_BUFFERS) {
 }

diff --git a/pidl/tests/typelist.pl b/pidl/tests/typelist.pl
index adefd65ca0b0f8becf8d1cd9ee69766cd9f1064d..e99b016487b9ad369f5d2942efbdea1ab511aef8 100755 (executable)
--- a/pidl/tests/typelist.pl
+++ b/pidl/tests/typelist.pl
@@ -71,7 +71,7 @@ is(0, scalar_is_reference({TYPE => "STRUCT", NAME => "echo_foobar"}));
 
 is("uint8", enum_type_fn({TYPE => "ENUM", PARENT=>{PROPERTIES => {enum8bit => 1}}}));
 is("uint32", enum_type_fn({TYPE => "ENUM", PARENT=>{PROPERTIES => {v1_enum => 1}}}));
-is("uint16", enum_type_fn({TYPE => "ENUM", PARENT=>{PROPERTIES => {}}}));
+is("uint1632", enum_type_fn({TYPE => "ENUM", PARENT=>{PROPERTIES => {}}}));
 
 is("uint8", bitmap_type_fn({TYPE => "BITMAP", PROPERTIES => {bitmap8bit => 1}}));
 is("uint16", bitmap_type_fn({TYPE => "BITMAP", PROPERTIES => {bitmap16bit => 1}}));

diff --git a/source3/Makefile.in b/source3/Makefile.in
index abd005a0ef6f28047fec66abd14cc4f9fc32bc75..4dbc8cd84e15cf185e44c860bd99ae230953aee5 100644 (file)
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -69,6 +69,7 @@ KRB5LIBS=@KRB5_LIBS@
 LDAP_LIBS=@LDAP_LIBS@
 NSCD_LIBS=@NSCD_LIBS@
 UUID_LIBS=@UUID_LIBS@
+LIBWBCLIENT=@LIBWBCLIENT_STATIC@ @LIBWBCLIENT_SHARED@
 LIBWBCLIENT_LIBS=@LIBWBCLIENT_LIBS@
 WINBIND_NSS_EXTRA_LIBS=@WINBIND_NSS_EXTRA_LIBS@
 WINBIND_NSS_PTHREAD=@WINBIND_NSS_PTHREAD@
@@ -76,10 +77,12 @@ PAM_WINBIND_EXTRA_LIBS=@PAM_WINBIND_EXTRA_LIBS@
 DNSSD_LIBS=@DNSSD_LIBS@
 AVAHI_LIBS=@AVAHI_LIBS@
 POPT_LIBS=@POPTLIBS@
+LIBTALLOC=@LIBTALLOC_STATIC@ @LIBTALLOC_SHARED@
 LIBTALLOC_LIBS=@LIBTALLOC_LIBS@
+LIBTDB=@LIBTDB_STATIC@ @LIBTDB_SHARED@
 LIBTDB_LIBS=@LIBTDB_LIBS@
+LIBNETAPI=@LIBNETAPI_STATIC@ @LIBNETAPI_SHARED@
 LIBNETAPI_LIBS=@LIBNETAPI_LIBS@
-LIBLUA_LIBS=@LIBLUA_LIBS@
 LIBSMBCLIENT_LIBS=@LIBSMBCLIENT_LIBS@
 LIBSMBSHAREMODES_LIBS=@LIBSMBSHAREMODES_LIBS@
 
@@ -503,7 +506,9 @@ SCHANNEL_OBJ = ../libcli/auth/credentials.o \
               passdb/secrets_schannel.o
 
 LIBSMB_OBJ = libsmb/clientgen.o libsmb/cliconnect.o libsmb/clifile.o \
-            libsmb/clikrb5.o libsmb/clispnego.o ../lib/util/asn1.o \
+            libsmb/clikrb5.o libsmb/clispnego.o \
+            ../libcli/auth/spnego_parse.o \
+            ../lib/util/asn1.o \
             libsmb/clirap.o libsmb/clierror.o libsmb/climessage.o \
             libsmb/clireadwrite.o libsmb/clilist.o libsmb/cliprint.o \
             libsmb/clitrans.o libsmb/clisecdesc.o libsmb/clidgram.o \
@@ -520,7 +525,8 @@ RPC_CLIENT_OBJ1 = rpc_client/cli_netlogon.o \
                  $(SCHANNEL_OBJ)
 
 LIBMSRPC_OBJ = rpc_client/cli_lsarpc.o rpc_client/cli_samr.o \
-              $(RPC_CLIENT_OBJ1) rpc_client/cli_reg.o $(RPC_CLIENT_OBJ) \
+              $(RPC_CLIENT_OBJ1) \
+              $(RPC_CLIENT_OBJ) \
               rpc_client/cli_spoolss.o \
               rpc_client/init_spoolss.o \
               rpc_client/init_samr.o \
@@ -593,6 +599,7 @@ REG_FULL_OBJ = $(REG_SMBCONF_OBJ) \
               $(REG_INIT_FULL_OBJ) \
               registry/reg_eventlog.o \
               registry/reg_perfcount.o \
+              librpc/gen_ndr/ndr_perfcount.o \
               registry/reg_util_legacy.o
 
 LIB_EVENTLOG_OBJ = lib/eventlog/eventlog.o
@@ -997,7 +1004,7 @@ NET_OBJ1 = utils/net.o utils/net_ads.o utils/net_help.o \
           $(PASSWD_UTIL_OBJ) utils/net_dns.o utils/net_ads_gpo.o \
           utils/net_conf.o utils/net_join.o utils/net_user.o \
           utils/net_group.o utils/net_file.o utils/net_registry.o \
-          auth/token_util.o utils/net_dom.o utils/net_share.o utils/net_lua.o \
+          auth/token_util.o utils/net_dom.o utils/net_share.o \
           utils/net_eventlog.o
 
 # these are not processed by make proto
@@ -1216,6 +1223,7 @@ WINBINDD_OBJ1 = \
                winbindd/winbindd_list_users.o \
                winbindd/winbindd_list_groups.o \
                winbindd/winbindd_check_machine_acct.o \
+               winbindd/winbindd_change_machine_acct.o \
                winbindd/winbindd_set_mapping.o \
                winbindd/winbindd_remove_mapping.o \
                winbindd/winbindd_set_hwm.o \
@@ -1395,7 +1403,7 @@ samba3-idl::
        @PIDL_OUTPUTDIR="librpc/gen_ndr" PIDL_ARGS="$(PIDL_ARGS)" CPP="$(CPP)" PIDL="../pidl/pidl" \
         srcdir="$(srcdir)" $(srcdir)/script/build_idl.sh \
                librpc/idl/messaging.idl librpc/idl/libnetapi.idl librpc/idl/notify.idl \
-               librpc/idl/wbint.idl
+               librpc/idl/wbint.idl librpc/idl/perfcount.idl
 
 #####################################################################
 
@@ -1529,7 +1537,7 @@ bin/.dummy:
          dir=bin $(MAKEDIR); fi
        @: >> $@ || : > $@ # what a fancy emoticon!
 
-bin/smbd@EXEEXT@: $(BINARY_PREREQS) $(SMBD_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@ @BUILD_POPT@
+bin/smbd@EXEEXT@: $(BINARY_PREREQS) $(SMBD_OBJ) $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT) @BUILD_POPT@
        @echo Linking $@
        @$(CC) -o $@ $(SMBD_OBJ) $(LDFLAGS) $(LDAP_LIBS) @SMBD_FAM_LIBS@ \
                $(KRB5LIBS) $(DYNEXP) $(PRINT_LIBS) $(AUTH_LIBS) \
@@ -1537,46 +1545,46 @@ bin/smbd@EXEEXT@: $(BINARY_PREREQS) $(SMBD_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGE
                $(POPT_LIBS) @SMBD_LIBS@ $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
                $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/nmbd@EXEEXT@: $(BINARY_PREREQS) $(NMBD_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/nmbd@EXEEXT@: $(BINARY_PREREQS) $(NMBD_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(NMBD_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(POPT_LIBS) \
                $(KRB5LIBS) $(LDAP_LIBS) $(ZLIB_LIBS)
 
-bin/swat@EXEEXT@: $(BINARY_PREREQS) $(SWAT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/swat@EXEEXT@: $(BINARY_PREREQS) $(SWAT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SWAT_OBJ) $(LDFLAGS) $(DYNEXP) $(PRINT_LIBS) \
          $(AUTH_LIBS) $(LIBS) $(PASSDB_LIBS) $(POPT_LIBS) $(KRB5LIBS) \
          $(LDAP_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/rpcclient@EXEEXT@: $(BINARY_PREREQS) $(RPCCLIENT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/rpcclient@EXEEXT@: $(BINARY_PREREQS) $(RPCCLIENT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(RPCCLIENT_OBJ) \
                $(DYNEXP) $(TERMLDFLAGS) $(TERMLIBS) $(LIBS) $(POPT_LIBS) \
                $(KRB5LIBS) $(LDAP_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
                $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS) $(PASSDB_LIBS)
 
-bin/smbclient@EXEEXT@: $(BINARY_PREREQS) $(CLIENT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbclient@EXEEXT@: $(BINARY_PREREQS) $(CLIENT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(CLIENT_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(TERMLDFLAGS) $(TERMLIBS) $(LIBS) $(POPT_LIBS) \
                $(KRB5LIBS) $(LDAP_LIBS) $(NSCD_LIBS) $(DNSSD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/net@EXEEXT@: $(BINARY_PREREQS) $(NET_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@ @LIBNETAPI_TARGET@ @LIBLUA_TARGET@
+bin/net@EXEEXT@: $(BINARY_PREREQS) $(NET_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT) $(LIBNETAPI)
        @echo Linking $@
        @$(CC) -o $@ $(NET_OBJ) $(DYNEXP) $(LDFLAGS) $(LIBS) \
                $(POPT_LIBS) $(KRB5LIBS) $(UUID_LIBS) $(LDAP_LIBS) \
                $(PASSDB_LIBS) $(TERMLDFLAGS) $(TERMLIBS) $(NSCD_LIBS) \
-               @INIPARSERLIBS@ $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(LIBNETAPI_LIBS)  $(LIBLUA_LIBS) -lm \
+               $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(LIBNETAPI_LIBS) \
                $(ZLIB_LIBS)
 
-bin/profiles@EXEEXT@: $(BINARY_PREREQS) $(PROFILES_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/profiles@EXEEXT@: $(BINARY_PREREQS) $(PROFILES_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(PROFILES_OBJ) $(DYNEXP) $(LDFLAGS) $(LIBS) \
                $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/smbspool@EXEEXT@: $(BINARY_PREREQS) $(CUPS_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/smbspool@EXEEXT@: $(BINARY_PREREQS) $(CUPS_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(CUPS_OBJ) $(DYNEXP) $(LDFLAGS) $(LIBS) \
                $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
@@ -1589,135 +1597,135 @@ bin/umount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UMOUNT_OBJ)
        @echo Linking $@
        @$(CC) -o $@ $(CIFS_UMOUNT_OBJ) $(DYNEXP) $(LDFLAGS)
 
-bin/cifs.upcall@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UPCALL_OBJ) $(LIBSMBCLIENT_OBJ1) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/cifs.upcall@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UPCALL_OBJ) $(LIBSMBCLIENT_OBJ1) $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(CIFS_UPCALL_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBSMBCLIENT_OBJ1) $(LIBS) -lkeyutils $(KRB5LIBS) \
                $(LDAP_LIBS) $(LIBTALLOC_LIBS) $(LIBWBCLIENT_LIBS) \
                $(LIBTDB_LIBS) $(NSCD_LIBS) $(ZLIB_LIBS)
 
-bin/testparm@EXEEXT@: $(BINARY_PREREQS) $(TESTPARM_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/testparm@EXEEXT@: $(BINARY_PREREQS) $(TESTPARM_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(TESTPARM_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/smbstatus@EXEEXT@: $(BINARY_PREREQS) $(STATUS_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/smbstatus@EXEEXT@: $(BINARY_PREREQS) $(STATUS_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(STATUS_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/smbcontrol@EXEEXT@: $(BINARY_PREREQS) $(SMBCONTROL_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/smbcontrol@EXEEXT@: $(BINARY_PREREQS) $(SMBCONTROL_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -DUSING_SMBCONTROL -o $@ \
                $(SMBCONTROL_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(LDAP_LIBS) @LIBUNWIND_PTRACE@ $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/smbtree@EXEEXT@: $(BINARY_PREREQS) $(SMBTREE_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbtree@EXEEXT@: $(BINARY_PREREQS) $(SMBTREE_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SMBTREE_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/smbpasswd@EXEEXT@: $(BINARY_PREREQS) $(SMBPASSWD_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbpasswd@EXEEXT@: $(BINARY_PREREQS) $(SMBPASSWD_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SMBPASSWD_OBJ) $(LDFLAGS) $(PASSDB_LIBS) \
                $(DYNEXP) $(LIBS) $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/pdbedit@EXEEXT@: $(BINARY_PREREQS) $(PDBEDIT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/pdbedit@EXEEXT@: $(BINARY_PREREQS) $(PDBEDIT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(PDBEDIT_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(POPT_LIBS) $(PASSDB_LIBS) $(LDAP_LIBS) $(LIBTALLOC_LIBS) \
                $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS)
 
-bin/smbget@EXEEXT@: $(BINARY_PREREQS) $(SMBGET_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbget@EXEEXT@: $(BINARY_PREREQS) $(SMBGET_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SMBGET_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(POPT_LIBS)  $(KRB5LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/nmblookup@EXEEXT@: $(BINARY_PREREQS) $(NMBLOOKUP_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/nmblookup@EXEEXT@: $(BINARY_PREREQS) $(NMBLOOKUP_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(NMBLOOKUP_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(POPT_LIBS) $(LDAP_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/smbtorture@EXEEXT@: $(BINARY_PREREQS) $(SMBTORTURE_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbtorture@EXEEXT@: $(BINARY_PREREQS) $(SMBTORTURE_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SMBTORTURE_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) \
                $(LIBTDB_LIBS) $(ZLIB_LIBS) $(LIBWBCLIENT_LIBS)
 
-bin/talloctort@EXEEXT@: $(BINARY_PREREQS) $(TALLOCTORT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/talloctort@EXEEXT@: $(BINARY_PREREQS) $(TALLOCTORT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(TALLOCTORT_OBJ) $(LDFLAGS) \
                $(DYNEXP) $(LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/replacetort@EXEEXT@: $(REPLACETORT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@
+bin/replacetort@EXEEXT@: $(REPLACETORT_OBJ) @BUILD_POPT@ $(LIBTALLOC)
        @echo Linking $@
        @$(CC) @PIE_LDFLAGS@ -o $@ $(REPLACETORT_OBJ) $(LDFLAGS) \
                $(DYNEXP) $(LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS)
 
-bin/smbconftort@EXEEXT@: $(SMBCONFTORT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/smbconftort@EXEEXT@: $(SMBCONFTORT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) @PIE_LDFLAGS@ -o $@ $(SMBCONFTORT_OBJ) $(LDFLAGS) \
                $(DYNEXP) $(LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/masktest@EXEEXT@: $(BINARY_PREREQS) $(MASKTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/masktest@EXEEXT@: $(BINARY_PREREQS) $(MASKTEST_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(MASKTEST_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
 
-bin/msgtest@EXEEXT@: $(BINARY_PREREQS) $(MSGTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/msgtest@EXEEXT@: $(BINARY_PREREQS) $(MSGTEST_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(MSGTEST_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
 
-bin/smbcacls@EXEEXT@: $(BINARY_PREREQS) $(SMBCACLS_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbcacls@EXEEXT@: $(BINARY_PREREQS) $(SMBCACLS_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SMBCACLS_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/smbcquotas@EXEEXT@: $(BINARY_PREREQS) $(SMBCQUOTAS_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/smbcquotas@EXEEXT@: $(BINARY_PREREQS) $(SMBCQUOTAS_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(SMBCQUOTAS_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/eventlogadm@EXEEXT@: $(BINARY_PREREQS) $(EVTLOGADM_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/eventlogadm@EXEEXT@: $(BINARY_PREREQS) $(EVTLOGADM_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(EVTLOGADM_OBJ) $(DYNEXP) $(LDFLAGS) \
-               $(LIBS) $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
+               $(LIBS) $(LDAP_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/sharesec@EXEEXT@: $(BINARY_PREREQS) $(SHARESEC_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/sharesec@EXEEXT@: $(BINARY_PREREQS) $(SHARESEC_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(SHARESEC_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/locktest@EXEEXT@: $(BINARY_PREREQS) $(LOCKTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/locktest@EXEEXT@: $(BINARY_PREREQS) $(LOCKTEST_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(LOCKTEST_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
 
-bin/nsstest@EXEEXT@: $(BINARY_PREREQS) $(NSSTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/nsstest@EXEEXT@: $(BINARY_PREREQS) $(NSSTEST_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(NSSTEST_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS)  $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
 
-bin/pdbtest@EXEEXT@: $(BINARY_PREREQS) $(PDBTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/pdbtest@EXEEXT@: $(BINARY_PREREQS) $(PDBTEST_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(PDBTEST_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(PASSDB_LIBS) \
                $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/vfstest@EXEEXT@: $(BINARY_PREREQS) $(VFSTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/vfstest@EXEEXT@: $(BINARY_PREREQS) $(VFSTEST_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(VFSTEST_OBJ) $(LDFLAGS) $(TERMLDFLAGS) $(AVAHI_LIBS) \
                $(TERMLIBS) $(DYNEXP) $(PRINT_LIBS) $(AUTH_LIBS) $(DNSSD_LIBS) \
@@ -1725,65 +1733,65 @@ bin/vfstest@EXEEXT@: $(BINARY_PREREQS) $(VFSTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_TA
                @SMBD_LIBS@ $(NSCD_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
                $(LIBWBCLIENT_LIBS) $(ZLIB_LIBS)
 
-bin/smbiconv@EXEEXT@: $(BINARY_PREREQS) $(SMBICONV_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/smbiconv@EXEEXT@: $(BINARY_PREREQS) $(SMBICONV_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(SMBICONV_OBJ) $(LDFLAGS) $(TERMLDFLAGS) \
                $(TERMLIBS) $(DYNEXP) $(LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/log2pcap@EXEEXT@: $(BINARY_PREREQS) $(LOG2PCAP_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@
+bin/log2pcap@EXEEXT@: $(BINARY_PREREQS) $(LOG2PCAP_OBJ) @BUILD_POPT@ $(LIBTALLOC)
        @echo Linking $@
        @$(CC) -o $@ $(LOG2PCAP_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(POPT_LIBS) $(LIBS) $(LIBTALLOC_LIBS)
 
-bin/locktest2@EXEEXT@: $(BINARY_PREREQS) $(LOCKTEST2_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/locktest2@EXEEXT@: $(BINARY_PREREQS) $(LOCKTEST2_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(LOCKTEST2_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
 
-bin/debug2html@EXEEXT@: $(BINARY_PREREQS) $(DEBUG2HTML_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@
+bin/debug2html@EXEEXT@: $(BINARY_PREREQS) $(DEBUG2HTML_OBJ) @BUILD_POPT@ $(LIBTALLOC)
        @echo Linking $@
        @$(CC) -o $@ $(DEBUG2HTML_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(LIBTALLOC_LIBS)
 
-bin/smbfilter@EXEEXT@: $(BINARY_PREREQS) $(SMBFILTER_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/smbfilter@EXEEXT@: $(BINARY_PREREQS) $(SMBFILTER_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(SMBFILTER_OBJ) $(LDFLAGS) $(LIBS) \
                $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
 
-bin/ldbedit: $(BINARY_PREREQS) $(LDBEDIT_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/ldbedit: $(BINARY_PREREQS) $(LDBEDIT_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDBEDIT_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/ldbsearch: $(BINARY_PREREQS) $(LDBSEARCH_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/ldbsearch: $(BINARY_PREREQS) $(LDBSEARCH_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDBSEARCH_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/ldbadd: $(BINARY_PREREQS) $(LDBADD_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/ldbadd: $(BINARY_PREREQS) $(LDBADD_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDBADD_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/ldbmodify: $(BINARY_PREREQS) $(LDBMODIFY_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/ldbmodify: $(BINARY_PREREQS) $(LDBMODIFY_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDBMODIFY_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/ldbdel: $(BINARY_PREREQS) $(LDBDEL_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/ldbdel: $(BINARY_PREREQS) $(LDBDEL_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDBDEL_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/ldbrename: $(BINARY_PREREQS) $(LDBRENAME_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/ldbrename: $(BINARY_PREREQS) $(LDBRENAME_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) $(FLAGS) -o $@ $(LDBRENAME_OBJ) $(DYNEXP) $(LDFLAGS) \
                $(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
@@ -1817,7 +1825,6 @@ LIBTALLOC_SHARED_TARGET=@LIBTALLOC_SHARED_TARGET@
 LIBTALLOC_SOVER=@LIBTALLOC_SOVER@
 LIBTALLOC_SHARED_TARGET_SONAME=$(LIBTALLOC_SHARED_TARGET).$(LIBTALLOC_SOVER)
 LIBTALLOC_STATIC_TARGET=@LIBTALLOC_STATIC_TARGET@
-LIBTALLOC=@LIBTALLOC_STATIC@ @LIBTALLOC_SHARED@
 LIBTALLOC_SYMS=$(srcdir)/exports/libtalloc.@SYMSEXT@
 LIBTALLOC_HEADERS=$(srcdir)/@tallocdir@/talloc.h
 
@@ -1873,7 +1880,6 @@ showlibtalloc:
        @echo  ""
        @echo "LIBTALLOC_SHARED               = @LIBTALLOC_SHARED@"
        @echo "LIBTALLOC_STATIC               = @LIBTALLOC_STATIC@"
-       @echo "LIBTALLOC_TARGET               = @LIBTALLOC_TARGET@"
        @echo "LIBTALLOC_LIBS                 = $(LIBTALLOC_LIBS)"
        @echo ""
        @echo "LIBTALLOC_SHARED_TARGET        = $(LIBTALLOC_SHARED_TARGET)"
@@ -1897,7 +1903,6 @@ LIBTDB_SHARED_TARGET=@LIBTDB_SHARED_TARGET@
 LIBTDB_SOVER=@LIBTDB_SOVER@
 LIBTDB_SHARED_TARGET_SONAME=$(LIBTDB_SHARED_TARGET).$(LIBTDB_SOVER)
 LIBTDB_STATIC_TARGET=@LIBTDB_STATIC_TARGET@
-LIBTDB=@LIBTDB_STATIC@ @LIBTDB_SHARED@
 LIBTDB_SYMS=$(srcdir)/exports/libtdb.@SYMSEXT@
 LIBTDB_HEADERS=$(srcdir)/@tdbdir@/include/tdb.h
 
@@ -1955,7 +1960,6 @@ showlibtdb:
        @echo  ""
        @echo "LIBTDB_SHARED               = @LIBTDB_SHARED@"
        @echo "LIBTDB_STATIC               = @LIBTDB_STATIC@"
-       @echo "LIBTDB_TARGET               = @LIBTDB_TARGET@"
        @echo "LIBTDB_LIBS                 = $(LIBTDB_LIBS)"
        @echo ""
        @echo "LIBTDB_SHARED_TARGET        = $(LIBTDB_SHARED_TARGET)"
@@ -1994,7 +1998,6 @@ LIBWBCLIENT_SHARED_TARGET=@LIBWBCLIENT_SHARED_TARGET@
 LIBWBCLIENT_SOVER=@LIBWBCLIENT_SOVER@
 LIBWBCLIENT_SHARED_TARGET_SONAME=$(LIBWBCLIENT_SHARED_TARGET).$(LIBWBCLIENT_SOVER)
 LIBWBCLIENT_STATIC_TARGET=@LIBWBCLIENT_STATIC_TARGET@
-LIBWBCLIENT=@LIBWBCLIENT_STATIC@ @LIBWBCLIENT_SHARED@
 LIBWBCLIENT_SYMS=$(srcdir)/exports/libwbclient.@SYMSEXT@
 LIBWBCLIENT_HEADERS=$(srcdir)/../nsswitch/libwbclient/wbclient.h \
                    $(srcdir)/../nsswitch/libwbclient/wbc_async.h
@@ -2002,9 +2005,9 @@ LIBWBCLIENT_HEADERS=$(srcdir)/../nsswitch/libwbclient/wbclient.h \
 $(LIBWBCLIENT_SYMS): $(LIBWBCLIENT_HEADERS)
        @$(MKSYMS_SH) $(AWK) $@ $(LIBWBCLIENT_HEADERS)
 
-$(LIBWBCLIENT_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBWBCLIENT_OBJ) $(LIBWBCLIENT_SYMS) @LIBTALLOC_TARGET@
+$(LIBWBCLIENT_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBWBCLIENT_OBJ) $(LIBWBCLIENT_SYMS) $(LIBTALLOC)
        @echo Linking shared library $@
-       @$(SHLD_DSO) $(LIBTALLOC_LIBS) $(LIBWBCLIENT_OBJ) \
+       @$(SHLD_DSO) $(LIBWBCLIENT_OBJ) $(LIBTALLOC_LIBS) \
                @SONAMEFLAG@`basename $@`
 
 $(LIBWBCLIENT_SHARED_TARGET): $(LIBWBCLIENT_SHARED_TARGET_SONAME)
@@ -2050,7 +2053,6 @@ showlibwbclient:
        @echo  ""
        @echo "LIBWBCLIENT_SHARED               = @LIBWBCLIENT_SHARED@"
        @echo "LIBWBCLIENT_STATIC               = @LIBWBCLIENT_STATIC@"
-       @echo "LIBWBCLIENT_TARGET               = @LIBWBCLIENT_TARGET@"
        @echo "LIBWBCLIENT_LIBS                 = $(LIBWBCLIENT_LIBS)"
        @echo ""
        @echo "LIBWBCLIENT_SHARED_TARGET        = $(LIBWBCLIENT_SHARED_TARGET)"
@@ -2077,7 +2079,7 @@ LIBADDNS=@LIBADDNS_STATIC@ @LIBADDNS_SHARED@
 #LIBADDNS_SYMS=$(srcdir)/exports/libaddns.@SYMSEXT@
 LIBADDNS_HEADERS=$(srcdir)/libaddns/addns.h
 
-$(LIBADDNS_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBADDNS_OBJ) @LIBTALLOC_TARGET@
+$(LIBADDNS_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBADDNS_OBJ) $(LIBTALLOC)
        @echo Linking shared library $@
        @$(SHLD_DSO) $(LIBADDNS_OBJ) $(LIBS) \
                $(KRB5LIBS) $(UUID_LIBS) $(LIBTALLOC_LIBS) \
@@ -2124,7 +2126,6 @@ showlibaddns:
        @echo  ""
        @echo "LIBADDNS_SHARED               = @LIBADDNS_SHARED@"
        @echo "LIBADDNS_STATIC               = @LIBADDNS_STATIC@"
-       @echo "LIBADDNS_TARGET               = @LIBADDNS_TARGET@"
        @echo "LIBADDNS_LIBS                 = $(LIBADDNS_LIBS)"
        @echo ""
        @echo "LIBADDNS_SHARED_TARGET        = $(LIBADDNS_SHARED_TARGET)"
@@ -2155,7 +2156,8 @@ LIBNETAPI_OBJ0 = lib/netapi/netapi.o \
                 lib/netapi/sid.o \
                 lib/netapi/share.o \
                 lib/netapi/file.o \
-                lib/netapi/shutdown.o
+                lib/netapi/shutdown.o \
+                lib/netapi/netlogon.o
 
 LIBNETAPI_OBJ  = $(LIBNETAPI_OBJ0) $(LIBNET_OBJ) \
                 $(LIBSMBCONF_OBJ) \
@@ -2171,14 +2173,13 @@ LIBNETAPI_SHARED_TARGET=@LIBNETAPI_SHARED_TARGET@
 LIBNETAPI_SOVER=@LIBNETAPI_SOVER@
 LIBNETAPI_SHARED_TARGET_SONAME=$(LIBNETAPI_SHARED_TARGET).$(LIBNETAPI_SOVER)
 LIBNETAPI_STATIC_TARGET=@LIBNETAPI_STATIC_TARGET@
-LIBNETAPI=@LIBNETAPI_STATIC@ @LIBNETAPI_SHARED@
 LIBNETAPI_SYMS=$(srcdir)/exports/libnetapi.@SYMSEXT@
 LIBNETAPI_HEADERS=$(srcdir)/lib/netapi/netapi.h
 
 $(LIBNETAPI_SYMS): $(LIBNETAPI_HEADERS)
        @$(MKSYMS_SH) $(AWK) $@ $(LIBNETAPI_HEADERS)
 
-$(LIBNETAPI_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBNETAPI_OBJ) $(LIBNETAPI_SYMS) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+$(LIBNETAPI_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBNETAPI_OBJ) $(LIBNETAPI_SYMS) $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking shared library $@
        @$(SHLD_DSO) $(LIBNETAPI_OBJ) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(LIBS) \
@@ -2230,7 +2231,6 @@ showlibnetapi:
        @echo  ""
        @echo "LIBNETAPI_SHARED               = @LIBNETAPI_SHARED@"
        @echo "LIBNETAPI_STATIC               = @LIBNETAPI_STATIC@"
-       @echo "LIBNETAPI_TARGET               = @LIBNETAPI_TARGET@"
        @echo "LIBNETAPI_LIBS                 = $(LIBNETAPI_LIBS)"
        @echo ""
        @echo "LIBNETAPI_SHARED_TARGET        = $(LIBNETAPI_SHARED_TARGET)"
@@ -2258,7 +2258,7 @@ LIBSMBCLIENT_HEADERS=$(srcdir)/include/libsmbclient.h
 $(LIBSMBCLIENT_SYMS): $(LIBSMBCLIENT_HEADERS)
        @$(MKSYMS_SH) $(AWK) $@ $(LIBSMBCLIENT_HEADERS)
 
-$(LIBSMBCLIENT_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBSMBCLIENT_OBJ) $(LIBSMBCLIENT_SYMS) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+$(LIBSMBCLIENT_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBSMBCLIENT_OBJ) $(LIBSMBCLIENT_SYMS) $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking shared library $@
        @$(SHLD_DSO) $(LIBSMBCLIENT_OBJ) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) $(LIBS) \
@@ -2313,7 +2313,6 @@ showlibsmbclient:
        @echo  ""
        @echo "LIBSMBCLIENT_SHARED               = @LIBSMBCLIENT_SHARED@"
        @echo "LIBSMBCLIENT_STATIC               = @LIBSMBCLIENT_STATIC@"
-       @echo "LIBSMBCLIENT_TARGET               = @LIBSMBCLIENT_TARGET@"
        @echo "LIBSMBCLIENT_LIBS                 = $(LIBSMBCLIENT_LIBS)"
        @echo ""
        @echo "LIBSMBCLIENT_SHARED_TARGET        = $(LIBSMBCLIENT_SHARED_TARGET)"
@@ -2345,11 +2344,10 @@ LIBSMBSHAREMODES_HEADERS=$(srcdir)/include/smb_share_modes.h
 $(LIBSMBSHAREMODES_SYMS): $(LIBSMBSHAREMODES_HEADERS)
        @$(MKSYMS_SH) $(AWK) $@ $(LIBSMBSHAREMODES_HEADERS)
 
-$(LIBSMBSHAREMODES_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBSMBSHAREMODES_OBJ) $(LIBSMBSHAREMODES_SYMS) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+$(LIBSMBSHAREMODES_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBSMBSHAREMODES_OBJ) $(LIBSMBSHAREMODES_SYMS) $(LIBTALLOC) $(LIBTDB)
        @echo Linking shared library $@
        @$(SHLD_DSO) $(LIBSMBSHAREMODES_OBJ) \
                $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
-               $(KRB5LIBS) $(LDAP_LIBS) \
                @SONAMEFLAG@`basename $@`
 
 $(LIBSMBSHAREMODES_SHARED_TARGET): $(LIBSMBSHAREMODES_SHARED_TARGET_SONAME)
@@ -2414,7 +2412,7 @@ showlibs:: showlibsmbsharemodes
 #-------------------------------------------------------------------
 
 # This is probably wrong for anything other than the GNU linker.
-bin/libbigballofmud.@SHLIBEXT@: $(BINARY_PREREQS) $(LIBBIGBALLOFMUD_OBJ) @LIBTALLOC_TARGET@
+bin/libbigballofmud.@SHLIBEXT@: $(BINARY_PREREQS) $(LIBBIGBALLOFMUD_OBJ) $(LIBTALLOC)
        @echo Linking shared library $@
        @$(SHLD) $(LDSHFLAGS) -o $@ $(LIBBIGBALLOFMUD_OBJ) \
                $(LIBS) $(LIBTALLOC_LIBS) \
@@ -2427,87 +2425,6 @@ bin/libbigballofmud.@SHLIBEXT@: $(BINARY_PREREQS) $(LIBBIGBALLOFMUD_OBJ) @LIBTAL
 # it can be fixed or if they just can't be called from a static
 # library.
 
-#-------------------------------------------------------------------
-#
-# libsmblua
-#
-#-------------------------------------------------------------------
-
-LIBLUA_OBJ0 = @LIBLUA_OBJ0@
-
-LIBLUA_OBJ = $(LIBLUA_OBJ0)
-
-LIBLUA_SHARED_TARGET=@LIBLUA_SHARED_TARGET@
-LIBLUA_SOVER=@LIBLUA_SOVER@
-LIBLUA_SHARED_TARGET_SONAME=$(LIBLUA_SHARED_TARGET).$(LIBLUA_SOVER)
-LIBLUA_STATIC_TARGET=@LIBLUA_STATIC_TARGET@
-LIBLUA=@LIBLUA_STATIC@ @LIBLUA_SHARED@
-LIBLUA_SYMS=$(srcdir)/exports/liblua.@SYMSEXT@
-LIBLUA_HEADERS=$(srcdir)/lua-5.1.4/src/lua.h
-
-$(LIBLUA_SHARED_TARGET_SONAME): $(BINARY_PREREQS) $(LIBLUA_OBJ) $(LIBLUA_SYMS) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
-       @echo Linking shared library $@
-       @$(SHLD_DSO) $(LIBLUA_OBJ) \
-               $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
-               $(KRB5LIBS) $(LDAP_LIBS) \
-               @SONAMEFLAG@`basename $@`
-
-$(LIBLUA_SHARED_TARGET): $(LIBLUA_SHARED_TARGET_SONAME)
-       @rm -f $@
-       @ln -f -s `basename $(LIBLUA_SHARED_TARGET_SONAME)` $@
-
-$(LIBLUA_STATIC_TARGET): $(BINARY_PREREQS) $(LIBLUA_OBJ0)
-       @echo Linking non-shared library $@
-       @-$(AR) -rc $@ $(LIBLUA_OBJ0)
-
-liblua: $(LIBLUA)
-
-cleanliblua::
-       -rm -f \
-               $(LIBLUA_SHARED_TARGET) \
-               $(LIBLUA_SHARED_TARGET_SONAME) \
-               $(LIBLUA_STATIC_TARGET)
-
-installliblua:: installdirs liblua
-       @$(SHELL) $(srcdir)/script/installdirs.sh $(INSTALLPERMS_BIN) $(DESTDIR) $(LIBDIR)
-       -$(INSTALLLIBCMD_SH) $(LIBLUA_SHARED_TARGET_SONAME) $(DESTDIR)$(LIBDIR)
-       @rm -f $(DESTDIR)$(LIBDIR)/`basename $(LIBLUA_SHARED_TARGET)`
-       -if test -f $(LIBLUA_SHARED_TARGET_SONAME) ; then \
-               ln -f -s `basename $(LIBLUA_SHARED_TARGET_SONAME)` \
-                       $(DESTDIR)$(LIBDIR)/`basename $(LIBLUA_SHARED_TARGET)` ; \
-       fi
-       -$(INSTALLLIBCMD_A) $(LIBLUA_STATIC_TARGET) $(DESTDIR)$(LIBDIR)
-       @$(SHELL) $(srcdir)/script/installdirs.sh $(INSTALLPERMS_BIN) $(DESTDIR) ${prefix}/include
-       -$(INSTALLCMD) -m $(INSTALLPERMS_DATA) $(LIBLUA_HEADERS) $(DESTDIR)${prefix}/include
-
-uninstallliblua::
-       -rm -f $(DESTDIR)$(LIBDIR)/`basename $(LIBLUA_SHARED_TARGET)`
-       -$(UNINSTALLLIBCMD_SH) $(DESTDIR)$(LIBDIR)/`basename $(LIBLUA_SHARED_TARGET_SONAME)`
-       -$(UNINSTALLLIBCMD_A) $(DESTDIR)$(LIBDIR)/`basename $(LIBLUA_STATIC_TARGET)`
-       -rm -f $(DESTDIR)${prefix}/include/smb_share_modes.h
-
-libs:: liblua
-installlibs:: @INSTALL_LIBLUA@
-uninstalllibs:: @UNINSTALL_LIBLUA@
-cleanlibs:: cleanliblua
-shlibs test_shlibs: @LIBLUA_SHARED@
-
-showliblua:
-       @echo  ""
-       @echo "LIBLUA_SHARED               = @LIBLUA_SHARED@"
-       @echo "LIBLUA_STATIC               = @LIBLUA_STATIC@"
-       @echo "LIBLUA_TARGET               = @LIBLUA_TARGET@"
-       @echo "LIBLUA_LIBS                 = $(LIBLUA_LIBS)"
-       @echo ""
-       @echo "LIBLUA_SHARED_TARGET        = $(LIBLUA_SHARED_TARGET)"
-       @echo "LIBLUA_SOVER                = $(LIBLUA_SOVER)"
-       @echo "LIBLUA_SHARED TARGET_SONAME = $(LIBLUA_SHARED_TARGET_SONAME)"
-       @echo "LIBLUA_STATIC_TARGET        = $(LIBLUA_STATIC_TARGET)"
-       @echo "LIBLUA                      = $(LIBLUA)"
-
-showlibs:: showliblua
-
-
 #####################################################################
 #
 # shared modules
@@ -2574,14 +2491,14 @@ bin/librpc_echo.@SHLIBEXT@: $(BINARY_PREREQS) $(RPC_ECHO_OBJ)
        @echo "Linking $@"
        @$(SHLD_MODULE) $(RPC_ECHO_OBJ)
 
-bin/winbindd@EXEEXT@: $(BINARY_PREREQS) $(WINBINDD_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/winbindd@EXEEXT@: $(BINARY_PREREQS) $(WINBINDD_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo "Linking $@"
        @$(CC) -o $@ $(WINBINDD_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) \
                $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) \
                $(PASSDB_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) \
                $(ZLIB_LIBS)
 
-bin/vlp@EXEEXT@: $(BINARY_PREREQS) $(VLP_OBJ) @LIBTDB_TARGET@
+bin/vlp@EXEEXT@: $(BINARY_PREREQS) $(VLP_OBJ) $(LIBTDB)
        @echo "Linking $@"
        @$(CC) -o $@ $(VLP_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(TERMLDFLAGS) $(TERMLIBS) $(LIBS) $(POPT_LIBS) \
@@ -2593,18 +2510,18 @@ bin/vlp@EXEEXT@: $(BINARY_PREREQS) $(VLP_OBJ) @LIBTDB_TARGET@
                $(WINBIND_NSS_EXTRA_LIBS) $(WINBIND_NSS_PTHREAD) \
                @SONAMEFLAG@`basename $@`@NSSSONAMEVERSIONSUFFIX@
 
-@WINBIND_WINS_NSS@: $(BINARY_PREREQS) $(WINBIND_WINS_NSS_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+@WINBIND_WINS_NSS@: $(BINARY_PREREQS) $(WINBIND_WINS_NSS_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo "Linking $@"
        @$(SHLD) $(LDSHFLAGS) -o $@ $(WINBIND_WINS_NSS_OBJ) \
                $(LDAP_LIBS) $(KRB5LIBS) $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS) \
                @SONAMEFLAG@`basename $@`@NSSSONAMEVERSIONSUFFIX@
 
-bin/winbind_krb5_locator.@SHLIBEXT@: $(BINARY_PREREQS) $(WINBIND_KRB5_LOCATOR_OBJ) @LIBWBCLIENT_TARGET@
+bin/winbind_krb5_locator.@SHLIBEXT@: $(BINARY_PREREQS) $(WINBIND_KRB5_LOCATOR_OBJ) $(LIBWBCLIENT)
        @echo "Linking $@"
        @$(SHLD) $(LDSHFLAGS) -o $@ $(WINBIND_KRB5_LOCATOR_OBJ) $(LIBWBCLIENT_LIBS) \
                @SONAMEFLAG@`basename $@`
 
-bin/pam_winbind.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_WINBIND_OBJ) @LIBTALLOC_TARGET@ @LIBWBCLIENT_TARGET@
+bin/pam_winbind.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_WINBIND_OBJ) $(LIBTALLOC) $(LIBWBCLIENT)
        @echo "Linking shared library $@"
        @$(SHLD) $(LDSHFLAGS) -o $@ $(PAM_WINBIND_OBJ) -lpam @INIPARSERLIBS@ \
                $(PAM_WINBIND_EXTRA_LIBS) $(LIBTALLOC_LIBS) $(LIBWBCLIENT_LIBS) @SONAMEFLAG@`basename $@`
@@ -2902,55 +2819,55 @@ bin/dirsort.@SHLIBEXT@: $(BINARY_PREREQS) $(VFS_DIRSORT_OBJ)
 ## None here right now
 #########################################################
 
-bin/wbinfo@EXEEXT@: $(BINARY_PREREQS) $(WBINFO_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/wbinfo@EXEEXT@: $(BINARY_PREREQS) $(WBINFO_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(WBINFO_OBJ) $(DYNEXP) $(LIBS) \
                $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
                $(LIBWBCLIENT_LIBS)
 
 bin/ntlm_auth@EXEEXT@: $(BINARY_PREREQS) $(NTLM_AUTH_OBJ) $(PARAM_OBJ) \
-       $(LIB_NONSMBD_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+       $(LIB_NONSMBD_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(DYNEXP) $(NTLM_AUTH_OBJ) \
                $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) $(LIBS) \
                $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS) @INIPARSERLIBS@
 
-bin/pam_smbpass.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_SMBPASS_OBJ) @LIBTALLOC_TARGET@ @LIBWBCLIENT_TARGET@ @LIBTDB_TARGET@
+bin/pam_smbpass.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_SMBPASS_OBJ) $(LIBTALLOC) $(LIBWBCLIENT) $(LIBTDB)
        @echo "Linking shared library $@"
        @$(SHLD) $(LDSHFLAGS) -o $@ $(PAM_SMBPASS_OBJ) -lpam $(DYNEXP) \
                $(LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
                $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(LIBWBCLIENT_LIBS)
 
-bin/tdbbackup@EXEEXT@: $(BINARY_PREREQS) $(TDBBACKUP_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/tdbbackup@EXEEXT@: $(BINARY_PREREQS) $(TDBBACKUP_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(TDBBACKUP_OBJ) $(DYNEXP) \
                $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/tdbtool@EXEEXT@: $(BINARY_PREREQS) $(TDBTOOL_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/tdbtool@EXEEXT@: $(BINARY_PREREQS) $(TDBTOOL_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(TDBTOOL_OBJ) $(DYNEXP) \
                $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/tdbdump@EXEEXT@: $(BINARY_PREREQS) $(TDBDUMP_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/tdbdump@EXEEXT@: $(BINARY_PREREQS) $(TDBDUMP_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(TDBDUMP_OBJ) $(DYNEXP) \
                $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/tdbtorture@EXEEXT@: $(BINARY_PREREQS) $(TDBTORTURE_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/tdbtorture@EXEEXT@: $(BINARY_PREREQS) $(TDBTORTURE_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo Linking $@
        @$(CC) -o $@ $(LDFLAGS) $(TDBTORTURE_OBJ) $(DYNEXP) \
                $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/t_strcmp@EXEEXT@: $(BINARY_PREREQS) @LIBTALLOC_TARGET@ bin/libbigballofmud.@SHLIBEXT@ torture/t_strcmp.o
+bin/t_strcmp@EXEEXT@: $(BINARY_PREREQS) $(LIBTALLOC) bin/libbigballofmud.@SHLIBEXT@ torture/t_strcmp.o
        $(CC) -o $@ $(DYNEXP) $(LIBS) $(LIBTALLOC_LIBS) \
                torture/t_strcmp.o -L ./bin -lbigballofmud
 
-bin/t_strstr@EXEEXT@: $(BINARY_PREREQS) @LIBTALLOC_TARGET@ bin/libbigballofmud.@SHLIBEXT@ torture/t_strstr.o
+bin/t_strstr@EXEEXT@: $(BINARY_PREREQS) $(LIBTALLOC) bin/libbigballofmud.@SHLIBEXT@ torture/t_strstr.o
        $(CC) -o $@ $(DYNEXP) $(LIBS) $(LIBTALLOC_LIBS) \
                torture/t_strstr.o -L ./bin -lbigballofmud
 
-bin/t_strappend@EXEEXT@: $(BINARY_PREREQS) @LIBTALLOC_TARGET@ bin/libbigballofmud.@SHLIBEXT@ torture/t_strappend.o
+bin/t_strappend@EXEEXT@: $(BINARY_PREREQS) $(LIBTALLOC) bin/libbigballofmud.@SHLIBEXT@ torture/t_strappend.o
        $(CC) -o $@ $(DYNEXP) $(LIBS) $(LIBTALLOC_LIBS) \
                torture/t_strappend.o -L ./bin -lbigballofmud
 
@@ -2962,20 +2879,20 @@ bin/timelimit@EXEEXT@: script/tests/timelimit.o
        @echo Linking $@
        @$(CC) -o $@ $(DYNEXP) script/tests/timelimit.o
 
-bin/rpc_open_tcp@EXEEXT@: $(BINARY_PREREQS) $(RPC_OPEN_TCP_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@ @LIBWBCLIENT_TARGET@
+bin/rpc_open_tcp@EXEEXT@: $(BINARY_PREREQS) $(RPC_OPEN_TCP_OBJ) $(LIBTALLOC) $(LIBTDB) $(LIBWBCLIENT)
        @echo "Linking $@"
        @$(CC) -o $@ $(RPC_OPEN_TCP_OBJ) $(LDFLAGS) $(DYNEXP) \
                $(LIBS) $(LIBTALLOC_LIBS) $(LIBWBCLIENT_LIBS) \
                $(LDAP_LIBS) $(KRB5LIBS) $(NSCD_LIBS)
 
-bin/test_lp_load@EXEEXT@: $(BINARY_PREREQS) $(TEST_LP_LOAD_OBJ) @BUILD_POPT@ @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/test_lp_load@EXEEXT@: $(BINARY_PREREQS) $(TEST_LP_LOAD_OBJ) @BUILD_POPT@ $(LIBTALLOC) $(LIBTDB)
        @echo "Linking $@"
        @$(CC) -o $@ $(TEST_LP_LOAD_OBJ) \
                $(LDFLAGS) $(DYNEEXP) $(LIBS) \
                $(LDAP_LIBS) \
                $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/dbwrap_tool@EXEEXT@: $(DBWRAP_TOOL_OBJ) @LIBTALLOC_TARGET@ @LIBTDB_TARGET@
+bin/dbwrap_tool@EXEEXT@: $(DBWRAP_TOOL_OBJ) $(LIBTALLOC) $(LIBTDB)
        @echo "Linking $@"
        @$(CC) -o $@ $(DBWRAP_TOOL_OBJ)\
                $(LDFLAGS) $(DYNEEXP) $(LIBS) \

diff --git a/source3/VERSION b/source3/VERSION
index 5296aff4ba6267d14b97a64c55178f3b5419ae52..51bb2b1ab44c9dee11df27610c1f07e0b2bb3de3 100644 (file)
--- a/source3/VERSION
+++ b/source3/VERSION
@@ -24,7 +24,7 @@
 #  ->  "3.0.0"                                         #
 ########################################################
 SAMBA_VERSION_MAJOR=3
-SAMBA_VERSION_MINOR=5
+SAMBA_VERSION_MINOR=6
 SAMBA_VERSION_RELEASE=0
 
 ########################################################

diff --git a/source3/auth/auth_domain.c b/source3/auth/auth_domain.c
index 7dec6ad84bf6524f79f797aad4631cfddae9997f..084d84ce29f0482d0d52bb26e191ef6561c8cff8 100644 (file)
--- a/source3/auth/auth_domain.c
+++ b/source3/auth/auth_domain.c
@@ -195,7 +195,7 @@ machine %s. Error was : %s.\n", dc_name, nt_errstr(result)));
        if (!lp_client_schannel()) {
                /* We need to set up a creds chain on an unauthenticated netlogon pipe. */
                uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
-               uint32 sec_chan_type = 0;
+               enum netr_SchannelType sec_chan_type = 0;
                unsigned char machine_pwd[16];
                const char *account_name;
 

diff --git a/source3/configure.in b/source3/configure.in
index e298ec658cf45aab2a1ee363b0e4d79377977f10..36c89efe2b4e9b24b1e16eaa35c6d8d533760818 100644 (file)
--- a/source3/configure.in
+++ b/source3/configure.in
@@ -72,7 +72,6 @@ AC_SUBST(LIBWBCLIENT_SHARED_TARGET)
 AC_SUBST(LIBWBCLIENT_SHARED)
 AC_SUBST(LIBWBCLIENT_STATIC_TARGET)
 AC_SUBST(LIBWBCLIENT_STATIC)
-AC_SUBST(LIBWBCLIENT_TARGET)
 AC_SUBST(LIBWBCLIENT_SOVER)
 AC_SUBST(LIBWBCLIENT)
 AC_SUBST(LIBWBCLIENT_LIBS)
@@ -381,10 +380,60 @@ AC_SUBST(DYNEXP)
 
 dnl Add modules that have to be built by default here
 dnl These have to be built static:
-default_static_modules="pdb_smbpasswd pdb_tdbsam pdb_wbc_sam rpc_lsarpc rpc_samr rpc_winreg rpc_initshutdown rpc_dssetup rpc_wkssvc rpc_svcctl rpc_ntsvcs rpc_netlogon rpc_netdfs rpc_srvsvc rpc_spoolss rpc_eventlog auth_sam auth_unix auth_winbind auth_wbc auth_server auth_domain auth_builtin auth_netlogond vfs_default nss_info_template"
+default_static_modules=""
+default_static_modules="$default_static_modules pdb_smbpasswd"
+default_static_modules="$default_static_modules pdb_tdbsam"
+default_static_modules="$default_static_modules pdb_wbc_sam"
+default_static_modules="$default_static_modules rpc_lsarpc"
+default_static_modules="$default_static_modules rpc_samr"
+default_static_modules="$default_static_modules rpc_winreg"
+default_static_modules="$default_static_modules rpc_initshutdown"
+default_static_modules="$default_static_modules rpc_dssetup"
+default_static_modules="$default_static_modules rpc_wkssvc"
+default_static_modules="$default_static_modules rpc_svcctl"
+default_static_modules="$default_static_modules rpc_ntsvcs"
+default_static_modules="$default_static_modules rpc_netlogon"
+default_static_modules="$default_static_modules rpc_netdfs"
+default_static_modules="$default_static_modules rpc_srvsvc"
+default_static_modules="$default_static_modules rpc_spoolss"
+default_static_modules="$default_static_modules rpc_eventlog"
+default_static_modules="$default_static_modules auth_sam"
+default_static_modules="$default_static_modules auth_unix"
+default_static_modules="$default_static_modules auth_winbind"
+default_static_modules="$default_static_modules auth_wbc"
+default_static_modules="$default_static_modules auth_server"
+default_static_modules="$default_static_modules auth_domain"
+default_static_modules="$default_static_modules auth_builtin"
+default_static_modules="$default_static_modules auth_netlogond"
+default_static_modules="$default_static_modules vfs_default"
+default_static_modules="$default_static_modules nss_info_template"
 
 dnl These are preferably build shared, and static if dlopen() is not available
-default_shared_modules="vfs_recycle vfs_audit vfs_extd_audit vfs_full_audit vfs_netatalk vfs_fake_perms vfs_default_quota vfs_readonly vfs_cap vfs_expand_msdfs vfs_shadow_copy vfs_shadow_copy2 charset_CP850 charset_CP437 auth_script vfs_readahead vfs_xattr_tdb vfs_streams_xattr vfs_streams_depot vfs_acl_xattr vfs_acl_tdb vfs_smb_traffic_analyzer vfs_preopen vfs_catia"
+default_shared_modules=""
+default_shared_modules="$default_shared_modules vfs_recycle"
+default_shared_modules="$default_shared_modules vfs_audit"
+default_shared_modules="$default_shared_modules vfs_extd_audit"
+default_shared_modules="$default_shared_modules vfs_full_audit"
+default_shared_modules="$default_shared_modules vfs_netatalk"
+default_shared_modules="$default_shared_modules vfs_fake_perms"
+default_shared_modules="$default_shared_modules vfs_default_quota"
+default_shared_modules="$default_shared_modules vfs_readonly"
+default_shared_modules="$default_shared_modules vfs_cap"
+default_shared_modules="$default_shared_modules vfs_expand_msdfs"
+default_shared_modules="$default_shared_modules vfs_shadow_copy"
+default_shared_modules="$default_shared_modules vfs_shadow_copy2"
+default_shared_modules="$default_shared_modules charset_CP850"
+default_shared_modules="$default_shared_modules charset_CP437"
+default_shared_modules="$default_shared_modules auth_script"
+default_shared_modules="$default_shared_modules vfs_readahead"
+default_shared_modules="$default_shared_modules vfs_xattr_tdb"
+default_shared_modules="$default_shared_modules vfs_streams_xattr"
+default_shared_modules="$default_shared_modules vfs_streams_depot"
+default_shared_modules="$default_shared_modules vfs_acl_xattr"
+default_shared_modules="$default_shared_modules vfs_acl_tdb"
+default_shared_modules="$default_shared_modules vfs_smb_traffic_analyzer"
+default_shared_modules="$default_shared_modules vfs_preopen"
+default_shared_modules="$default_shared_modules vfs_catia"
 
 if test "x$developer" = xyes; then
    default_static_modules="$default_static_modules rpc_rpcecho pdb_ads"
@@ -743,7 +792,7 @@ if test x$enable_cups != xno; then
                ac_save_PRINT_LIBS=$PRINT_LIBS
                CFLAGS="$CFLAGS `$CUPS_CONFIG --cflags`"
                LDFLAGS="$LDFLAGS `$CUPS_CONFIG --ldflags`"
-               PRINT_LIBS="-lcups"
+               PRINT_LIBS="$PRINT_LIBS -lcups"
                AC_CHECK_HEADERS(cups/cups.h cups/language.h)
                if test x"$ac_cv_header_cups_cups_h" = xyes -a \
                        x"$ac_cv_header_cups_language_h" = xyes; then
@@ -1706,6 +1755,23 @@ fi
 
 AC_MSG_RESULT($BLDSHARED)
 
+if test x"${ac_cv_prog_gnu_ld}" = x"yes"; then
+       saved_ldflags="$LDFLAGS"
+       AC_MSG_CHECKING([if --as-needed works])
+       LDFLAGS="--as-needed $saved_ldflags"
+       AC_TRY_LINK([],[],
+               [AC_MSG_RESULT([yes])
+               LD_AS_NEEDED_FLAG=--as-needed],
+               AC_MSG_RESULT([no]))
+       AC_MSG_CHECKING([if -Wl,--as-needed works])
+       LDFLAGS="-Wl,--as-needed $saved_ldflags"
+       AC_TRY_LINK([],[],
+               [AC_MSG_RESULT([yes])
+               LD_AS_NEEDED_FLAG=-Wl,--as-needed],
+               AC_MSG_RESULT([no]))
+       LDFLAGS="$LD_AS_NEEDED_FLAG $saved_ldflags"
+fi
+
 AC_MSG_CHECKING([LDFLAGS])
 AC_MSG_RESULT([$LDFLAGS])
 AC_MSG_CHECKING([DYNEXP])
@@ -3368,6 +3434,10 @@ if test x"$with_ads_support" != x"no"; then
   AC_CHECK_FUNC_EXT(krb5_fwd_tgt_creds, $KRB5_LIBS)
   AC_CHECK_FUNC_EXT(krb5_auth_con_set_req_cksumtype, $KRB5_LIBS)
 
+  # MIT krb5 1.7beta3 (in Ubuntu Karmic) does not have this declaration
+  # but does have the symbol
+  AC_CHECK_DECLS(krb5_auth_con_set_req_cksumtype, [], [], [#include <krb5.h>])
+
   LIBS="$KRB5_LIBS $LIBS"
 
   AC_CACHE_CHECK(whether krb5_ticket contains kvno and enctype,
@@ -4201,31 +4271,45 @@ fi # try_pam != no
 PAM_MODULES=""
 INSTALL_PAM_MODULES=""
 UNINSTALL_PAM_MODULES=""
+
+try_pam_smbpass=auto
 AC_MSG_CHECKING(whether to use pam_smbpass)
 AC_ARG_WITH(pam_smbpass,
-[AS_HELP_STRING([--with-pam_smbpass], [Build PAM module for authenticating against passdb backends (default=no)])],
+[AS_HELP_STRING([--with-pam_smbpass], [Build PAM module for authenticating against passdb backends (default=auto)])],
 [ case "$withval" in
-  yes)
-    AC_MSG_RESULT(yes)
+  yes|no|auto)
+    try_pam_smbpass=$withval
+  ;;
+  *)
+    AC_MSG_ERROR([valid options are yes,no,auto])
+  ;;
+  esac
+])
 
-       # Conditions under which pam_smbpass should not be built.
+if test x"${try_pam_smbpass}" = xno ; then
+       use_pam_smbpass=no
+else
+       use_pam_smbpass=yes
+       # Conditions under which pam_smbpass can't be built.
+       if test x"$BLDSHARED" != xtrue ; then
+               if test x"${try_pam_smbpass}" = xyes ; then
+                       AC_MSG_ERROR([No support for shared modules])
+               fi
+               use_pam_smbpass=no
+       elif test x"$create_pam_modules" != xyes ; then
+               if test x"${try_pam_smbpass}" = xyes ; then
+                       AC_MSG_ERROR([No support for PAM MODULES])
+               fi
+               use_pam_smbpass=no
+       fi
 
-       if test x"$BLDSHARED" != x"true"; then
-          AC_MSG_ERROR([No support for shared modules])
-       elif test x"$create_pam_modules" != x"yes"; then
-         AC_MSG_ERROR([No support for PAM MODULES])
-       else
-          PAM_MODULES="pam_smbpass"
-          INSTALL_PAM_MODULES="installpammodules"
-          UNINSTALL_PAM_MODULES="uninstallpammodules"
-       fi
-    ;;
-  *)
-    AC_MSG_RESULT(no)
-    ;;
-  esac ],
-  AC_MSG_RESULT(no)
-)
+       if test x"${use_pam_smbpass}" = xyes ; then 
+               PAM_MODULES="pam_smbpass"
+               INSTALL_PAM_MODULES="installpammodules"
+               UNINSTALL_PAM_MODULES="uninstallpammodules"
+       fi
+fi
+AC_MSG_RESULT([$use_pam_smbpass])
 
 
 ##
@@ -4740,7 +4824,7 @@ AC_ARG_ENABLE(external_libtalloc, [AS_HELP_STRING([--enable-external-libtalloc],
 
 if test "x$enable_external_libtalloc" != xno
 then
-       PKG_CHECK_MODULES(LIBTALLOC, talloc >= 2.0.0,
+       PKG_CHECK_MODULES(LIBTALLOC, talloc >= 2.0.1,
                [ enable_external_libtalloc=yes ],
                [ if test x$enable_external_libtalloc = xyes; then
                        AC_MSG_ERROR([Unable to find libtalloc])
@@ -4809,47 +4893,6 @@ then
        AC_SUBST(TDBTORTURE)
 fi
 
-
-AC_ARG_ENABLE(external_liblua,
-       [AS_HELP_STRING([--enable-external-liblua],
-               [Enable external lua [default=auto]])],
-               [ enable_external_liblua=$enableval ],
-               [ enable_external_liblua=auto ])
-
-if test "x$enable_external_liblua" != xno
-then
-       PKG_CHECK_MODULES(LIBLUA, lua5.1 >= 5.1.4,
-               [ enable_external_liblua=yes ],
-               [
-               if test x$enable_external_liblua = xyes; then
-                       AC_MSG_ERROR([Unable to find liblua])
-               else
-                       enable_external_liblua=no
-               fi
-               ])
-fi
-
-AC_SUBST(LIBLUA_OBJ0)
-if test "x$enable_external_liblua" = xno
-then
-       LINK_LIBLUA=STATIC
-       SMB_LIBRARY(lua, 0)
-       LIBLUA_OBJ0="lua-5.1.4/src/lapi.o lua-5.1.4/src/lauxlib.o \
-               lua-5.1.4/src/lbaselib.o lua-5.1.4/src/lcode.o \
-               lua-5.1.4/src/ldblib.o lua-5.1.4/src/ldebug.o lua-5.1.4/src/ldo.o \
-               lua-5.1.4/src/ldump.o lua-5.1.4/src/lfunc.o lua-5.1.4/src/lgc.o \
-               lua-5.1.4/src/linit.o lua-5.1.4/src/liolib.o lua-5.1.4/src/llex.o \
-               lua-5.1.4/src/lmathlib.o lua-5.1.4/src/lmem.o \
-               lua-5.1.4/src/loadlib.o lua-5.1.4/src/lobject.o \
-               lua-5.1.4/src/lopcodes.o lua-5.1.4/src/loslib.o \
-               lua-5.1.4/src/lparser.o lua-5.1.4/src/lstate.o \
-               lua-5.1.4/src/lstring.o lua-5.1.4/src/lstrlib.o \
-               lua-5.1.4/src/ltable.o lua-5.1.4/src/ltablib.o lua-5.1.4/src/ltm.o \
-               lua-5.1.4/src/lundump.o lua-5.1.4/src/lvm.o \
-               lua-5.1.4/src/lzio.o lua-5.1.4/src/print.o"
-       AC_SUBST(LIBLUA_OBJ0)
-fi
-
 SMB_LIBRARY(netapi, 0)
 SMB_LIBRARY(smbclient, 0)
 SMB_LIBRARY(smbsharemodes, 0)
@@ -5987,14 +6030,12 @@ else
                ## Only worry about libwbclient if we have shared
                # library support
                LIBWBCLIENT_SHARED=$LIBWBCLIENT_SHARED_TARGET
-               LIBWBCLIENT_TARGET=$LIBWBCLIENT_SHARED_TARGET
                LIBWBCLIENT=libwbclient
                INSTALL_LIBWBCLIENT=installlibwbclient
                UNINSTALL_LIBWBCLIENT=uninstalllibwbclient
                LIBWBCLIENT_LIBS="-lwbclient"
        else
                LIBWBCLIENT_STATIC=$LIBWBCLIENT_STATIC_TARGET
-               LIBWBCLIENT_TARGET=$LIBWBCLIENT_STATIC_TARGET
                LIBWBCLIENT_LIBS=$LIBWBCLIENT_STATIC_TARGET
        fi
 fi

diff --git a/source3/include/ads.h b/source3/include/ads.h
index 6d9b0eebac1ea4a1aa70eef3c37cdddee7580b6b..30f0b1fc0c5663dda8d2d11d15cd37479f3fe622 100644 (file)
--- a/source3/include/ads.h
+++ b/source3/include/ads.h
@@ -211,9 +211,6 @@ typedef void **ADS_MODLIST;
 #define ADS_LDAP_MATCHING_RULE_BIT_OR  "1.2.840.113556.1.4.804"
 
 #define ADS_PINGS          0x0000FFFF  /* Ping response */
-#define ADS_DNS_CONTROLLER 0x20000000  /* DomainControllerName is a DNS name*/
-#define ADS_DNS_DOMAIN     0x40000000  /* DomainName is a DNS name */
-#define ADS_DNS_FOREST     0x80000000  /* DnsForestName is a DNS name */
 
 /* ads auth control flags */
 #define ADS_AUTH_DISABLE_KERBEROS 0x0001

diff --git a/source3/include/includes.h b/source3/include/includes.h
index 71125140becce92e5df96114442c8bf15cda5e48..b3446cbf65abe1787251cd1104327ac2ba28f2bc 100644 (file)
--- a/source3/include/includes.h
+++ b/source3/include/includes.h
@@ -621,7 +621,7 @@ struct smb_iconv_convenience *lp_iconv_convenience(void *lp_ctx);
 #include "tdb.h"
 #include "util_tdb.h"
 
-#include "../talloc/talloc.h"
+#include "talloc.h"
 
 #include "event.h"
 #include "../lib/util/tevent_unix.h"
@@ -672,8 +672,7 @@ struct smb_iconv_convenience *lp_iconv_convenience(void *lp_ctx);
 #include "ntdomain.h"
 #include "reg_objects.h"
 #include "reg_db.h"
-#include "rpc_perfcount.h"
-#include "rpc_perfcount_defs.h"
+#include "librpc/gen_ndr/perfcount.h"
 #include "librpc/gen_ndr/notify.h"
 #include "librpc/gen_ndr/xattr.h"
 #include "librpc/gen_ndr/messaging.h"

diff --git a/source3/include/nss_info.h b/source3/include/nss_info.h
index 90d992a3b948a7421a77602b8e638dcbfa967828..75142898893ac467afccdcf4e4f13ea21d5251e9 100644 (file)
--- a/source3/include/nss_info.h
+++ b/source3/include/nss_info.h
@@ -8,12 +8,12 @@
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 3 of the License, or (at your option) any later version.
-   
+
    This library 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
    Library General Public License for more details.
-   
+
    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -36,7 +36,7 @@
 
 struct nss_function_entry {
        struct nss_function_entry *prev, *next;
-       
+
        const char *name;
        struct nss_info_methods *methods;
 };
@@ -83,8 +83,6 @@ NTSTATUS smb_register_idmap_nss(int version,
                                const char *name, 
                                struct nss_info_methods *methods);
 
-NTSTATUS nss_init( const char **nss_list );
-
 NTSTATUS nss_get_info( const char *domain, const DOM_SID *user_sid,
                       TALLOC_CTX *ctx,
                       ADS_STRUCT *ads, LDAPMessage *msg,

diff --git a/source3/include/proto.h b/source3/include/proto.h
index d664a26949cf31bc81b3082d719f8bb743f1f192..4f33a4adf69fefbd464f213d4d1e9e338a9263c8 100644 (file)
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -937,7 +937,7 @@ SMB_OFF_T sys_ftell(FILE *fp);
 int sys_creat(const char *path, mode_t mode);
 int sys_open(const char *path, int oflag, mode_t mode);
 FILE *sys_fopen(const char *path, const char *type);
-void kernel_flock(int fd, uint32 share_mode);
+void kernel_flock(int fd, uint32 share_mode, uint32 access_mask);
 SMB_STRUCT_DIR *sys_opendir(const char *name);
 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp);
 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset);
@@ -1259,6 +1259,10 @@ struct passwd *getpwuid_alloc(TALLOC_CTX *mem_ctx, uid_t uid) ;
 const char *reg_type_lookup(enum winreg_Type type);
 WERROR reg_pull_multi_sz(TALLOC_CTX *mem_ctx, const void *buf, size_t len,
                         uint32 *num_values, char ***values);
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s);
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a);
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s);
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char ***a);
 
 /* The following definitions come from lib/util_reg_api.c  */
 
@@ -1572,12 +1576,6 @@ void load_case_tables(void);
 void init_valid_table(void);
 size_t dos_PutUniCode(char *dst,const char *src, size_t len, bool null_terminate);
 char *skip_unibuf(char *src, size_t len);
-int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags);
-int rpcstr_pull_talloc(TALLOC_CTX *ctx,
-                       char **dest,
-                       void *src,
-                       int src_len,
-                       int flags);
 int rpcstr_push(void *dest, const char *src, size_t dest_len, int flags);
 int rpcstr_push_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src);
 smb_ucs2_t toupper_w(smb_ucs2_t val);
@@ -2661,6 +2659,14 @@ struct tevent_req *cli_posix_rmdir_send(TALLOC_CTX *mem_ctx,
                                        const char *fname);
 NTSTATUS cli_posix_rmdir_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 NTSTATUS cli_posix_rmdir(struct cli_state *cli, const char *fname);
+struct tevent_req *cli_notify_send(TALLOC_CTX *mem_ctx,
+                                  struct tevent_context *ev,
+                                  struct cli_state *cli, uint16_t fnum,
+                                  uint32_t buffer_size,
+                                  uint32_t completion_filter, bool recursive);
+NTSTATUS cli_notify_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                        uint32_t *pnum_changes,
+                        struct notify_change **pchanges);
 
 /* The following definitions come from libsmb/clifsinfo.c  */
 
@@ -3309,8 +3315,9 @@ void update_trustdom_cache( void );
 
 NTSTATUS trust_pw_change_and_store_it(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, 
                                      const char *domain,
+                                     const char *account_name,
                                      unsigned char orig_trust_passwd_hash[16],
-                                     uint32 sec_channel_type);
+                                     enum netr_SchannelType sec_channel_type);
 NTSTATUS trust_pw_find_change_and_store_it(struct rpc_pipe_client *cli, 
                                           TALLOC_CTX *mem_ctx, 
                                           const char *domain) ;
@@ -3978,6 +3985,7 @@ char *lp_ldap_suffix(void);
 char *lp_ldap_admin_dn(void);
 int lp_ldap_ssl(void);
 bool lp_ldap_ssl_ads(void);
+int lp_ldap_ref_follow(void);
 int lp_ldap_passwd_sync(void);
 bool lp_ldap_delete_dn(void);
 int lp_ldap_replication_sleep(void);
@@ -4437,9 +4445,11 @@ bool pdb_update_autolock_flag(struct samu *sampass, bool *updated);
 bool pdb_increment_bad_password_count(struct samu *sampass);
 bool is_dc_trusted_domain_situation(const char *domain_name);
 bool get_trust_pw_clear(const char *domain, char **ret_pwd,
-                       const char **account_name, uint32 *channel);
+                       const char **account_name,
+                       enum netr_SchannelType *channel);
 bool get_trust_pw_hash(const char *domain, uint8 ret_pwd[16],
-                      const char **account_name, uint32 *channel);
+                      const char **account_name,
+                      enum netr_SchannelType *channel);
 struct samr_LogonHours get_logon_hours_from_pdb(TALLOC_CTX *mem_ctx,
                                                struct samu *pw);
 /* The following definitions come from passdb/pdb_compat.c  */
@@ -4672,14 +4682,14 @@ bool secrets_fetch_domain_sid(const char *domain, DOM_SID *sid);
 bool secrets_store_domain_guid(const char *domain, struct GUID *guid);
 bool secrets_fetch_domain_guid(const char *domain, struct GUID *guid);
 void *secrets_get_trust_account_lock(TALLOC_CTX *mem_ctx, const char *domain);
-uint32 get_default_sec_channel(void);
+enum netr_SchannelType get_default_sec_channel(void);
 bool secrets_fetch_trust_account_password_legacy(const char *domain,
                                                 uint8 ret_pwd[16],
                                                 time_t *pass_last_set_time,
-                                                uint32 *channel);
+                                                enum netr_SchannelType *channel);
 bool secrets_fetch_trust_account_password(const char *domain, uint8 ret_pwd[16],
                                          time_t *pass_last_set_time,
-                                         uint32 *channel);
+                                         enum netr_SchannelType *channel);
 bool secrets_fetch_trusted_domain_password(const char *domain, char** pwd,
                                            DOM_SID *sid, time_t *pass_last_set_time);
 bool secrets_store_trusted_domain_password(const char* domain, const char* pwd,
@@ -4687,10 +4697,10 @@ bool secrets_store_trusted_domain_password(const char* domain, const char* pwd,
 bool secrets_delete_machine_password(const char *domain);
 bool secrets_delete_machine_password_ex(const char *domain);
 bool secrets_delete_domain_sid(const char *domain);
-bool secrets_store_machine_password(const char *pass, const char *domain, uint32 sec_channel);
+bool secrets_store_machine_password(const char *pass, const char *domain, enum netr_SchannelType sec_channel);
 char *secrets_fetch_machine_password(const char *domain,
                                     time_t *pass_last_set_time,
-                                    uint32 *channel);
+                                    enum netr_SchannelType *channel);
 bool trusted_domain_password_delete(const char *domain);
 bool secrets_store_ldap_pw(const char* dn, char* pw);
 bool fetch_ldap_pw(char **dn, char** pw);
@@ -5115,12 +5125,14 @@ struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
                                   const char *data_p, size_t size);
 int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
                        const char *data_p, size_t size);
+int regval_ctr_addvalue_sz(struct regval_ctr *ctr, const char *name, const char *data);
+int regval_ctr_addvalue_multi_sz(struct regval_ctr *ctr, const char *name, const char **data);
 int regval_ctr_copyvalue(struct regval_ctr *ctr, struct regval_blob *val);
 int regval_ctr_delvalue(struct regval_ctr *ctr, const char *name);
 struct regval_blob* regval_ctr_getvalue(struct regval_ctr *ctr,
                                        const char *name);
 uint32 regval_dword(struct regval_blob *val);
-char *regval_sz(struct regval_blob *val);
+const char *regval_sz(struct regval_blob *val);
 
 /* The following definitions come from registry/reg_perfcount.c  */
 
@@ -5130,20 +5142,6 @@ uint32 reg_perfcount_get_last_counter(uint32 base_index);
 uint32 reg_perfcount_get_last_help(uint32 last_counter);
 uint32 reg_perfcount_get_counter_help(uint32 base_index, char **retbuf);
 uint32 reg_perfcount_get_counter_names(uint32 base_index, char **retbuf);
-bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data);
-bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst,
-                                     prs_struct *ps,
-                                     int instId,
-                                     PERF_OBJECT_TYPE *obj,
-                                     TDB_CONTEXT *names);
-bool _reg_perfcount_add_instance(PERF_OBJECT_TYPE *obj,
-                                prs_struct *ps,
-                                int instInd,
-                                TDB_CONTEXT *names);
-uint32 reg_perfcount_get_perf_data_block(uint32 base_index, 
-                                        prs_struct *ps, 
-                                        PERF_DATA_BLOCK *block,
-                                        const char *object_ids);
 WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32 max_buf_size, uint32 *outbuf_len, const char *object_ids);
 
 /* The following definitions come from registry/reg_util.c  */
@@ -5153,8 +5151,6 @@ bool reg_split_key(char *path, char **base, char **key);
 char *normalize_reg_path(TALLOC_CTX *ctx, const char *keyname );
 void normalize_dbkey(char *key);
 char *reg_remaining_path(TALLOC_CTX *ctx, const char *key);
-int regval_convert_multi_sz( uint16 *multi_string, size_t byte_len, char ***values );
-size_t regval_build_multi_sz( char **values, uint16 **buffer );
 
 /* The following definitions come from registry/reg_util_legacy.c  */
 
@@ -5253,10 +5249,11 @@ NTSTATUS rpccli_netlogon_sam_network_logon_ex(struct rpc_pipe_client *cli,
                                              struct netr_SamInfo3 **info3);
 NTSTATUS rpccli_netlogon_set_trust_password(struct rpc_pipe_client *cli,
                                            TALLOC_CTX *mem_ctx,
+                                           const char *account_name,
                                            const unsigned char orig_trust_passwd_hash[16],
                                            const char *new_trust_pwd_cleartext,
                                            const unsigned char new_trust_passwd_hash[16],
-                                           uint32_t sec_channel_type);
+                                           enum netr_SchannelType sec_channel_type);
 
 /* The following definitions come from rpc_client/cli_pipe.c  */
 
@@ -5418,12 +5415,6 @@ NTSTATUS rpc_transport_smbd_init(TALLOC_CTX *mem_ctx,
 NTSTATUS rpc_transport_sock_init(TALLOC_CTX *mem_ctx, int fd,
                                 struct rpc_cli_transport **presult);
 
-/* The following definitions come from rpc_client/cli_reg.c  */
-
-NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
-                         uint32 reg_type, uint32 access_mask,
-                         struct policy_handle *reg_hnd);
-
 /* The following definitions come from rpc_client/cli_samr.c  */
 
 NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli,
@@ -5449,7 +5440,7 @@ NTSTATUS rpccli_samr_chgpasswd_user3(struct rpc_pipe_client *cli,
                                     const char *newpassword,
                                     const char *oldpassword,
                                     struct samr_DomInfo1 **dominfo1,
-                                    struct samr_ChangeReject **reject);
+                                    struct userPwdChangeFailureInformation **reject);
 void get_query_dispinfo_params(int loop_count, uint32 *max_entries,
                               uint32 *max_size);
 NTSTATUS rpccli_try_samr_connects(struct rpc_pipe_client *cli,
@@ -5644,11 +5635,8 @@ NTSTATUS cli_do_rpc_ndr(struct rpc_pipe_client *cli,
 /* The following definitions come from rpc_parse/parse_misc.c  */
 
 bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth);
-bool smb_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime);
-bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime);
 bool smb_io_uuid(const char *desc, struct GUID *uuid, 
                 prs_struct *ps, int depth);
-void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags);
 
 /* The following definitions come from rpc_parse/parse_prs.c  */
 
@@ -5699,7 +5687,6 @@ bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint
 bool prs_uint16s(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len);
 bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len);
 bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str);
-bool prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size);
 bool prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
 bool prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
 
@@ -6104,8 +6091,8 @@ NTSTATUS pass_oem_change(char *user,
                         const uchar old_lm_hash_encrypted[16],
                         uchar password_encrypted_with_nt_hash[516],
                         const uchar old_nt_hash_encrypted[16],
-                        uint32 *reject_reason);
-NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passwd, bool as_root, uint32 *samr_reject_reason);
+                        enum samPwdChangeReason *reject_reason);
+NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passwd, bool as_root, enum samPwdChangeReason *samr_reject_reason);
 
 /* The following definitions come from smbd/close.c  */
 
@@ -7142,6 +7129,7 @@ int vfs_stat_smb_fname(struct connection_struct *conn, const char *fname,
                       SMB_STRUCT_STAT *psbuf);
 int vfs_lstat_smb_fname(struct connection_struct *conn, const char *fname,
                        SMB_STRUCT_STAT *psbuf);
+NTSTATUS vfs_stat_fsp(files_struct *fsp);
 
 /* The following definitions come from torture/denytest.c  */
 

diff --git a/source3/include/rpc_misc.h b/source3/include/rpc_misc.h
index 797e1926db34d9433cf6dead0ed2bee21203d292..58ea91683a4b4add3896872b6adbade0d0569744 100644 (file)
--- a/source3/include/rpc_misc.h
+++ b/source3/include/rpc_misc.h
@@ -24,10 +24,6 @@
 #define _RPC_MISC_H 
 
 #define SMB_RPC_INTERFACE_VERSION 1
-#define PRS_POINTER_CAST bool (*)(const char*, prs_struct*, int, void*)
-
-enum unistr2_term_codes { UNI_FLAGS_NONE = 0, UNI_STR_TERMINATE = 1, UNI_MAXLEN_TERMINATE = 2, UNI_BROKEN_NON_NULL = 3, UNI_STR_DBLTERMINATE = 4 };
-
 
 
 /********************************************************************** 
@@ -107,33 +103,4 @@ typedef struct {           /* UNISTR - unicode string size and buffer */
                                   little-endian. ***MUST*** be null-terminated */
 } UNISTR;
 
-typedef struct {               /* UNISTR2 - unicode string size (in 
-                                  uint16 unicode chars) and buffer */
-       uint32 uni_max_len;
-       uint32 offset;
-       uint32 uni_str_len;
-       uint16 *buffer;         /* unicode characters. ***MUST*** be little-endian. 
-                                 **must** be null-terminated and the uni_str_len 
-                                 should include the NULL character */
-} UNISTR2;
-
-/*
- * I'm really wondering how many different time formats
- * I will have to cope with
- *
- * JFM, 09/13/98 In a mad mood ;-(
-*/
-typedef struct systemtime
-{
-       uint16 year;
-       uint16 month;
-       uint16 dayofweek;
-       uint16 day;
-       uint16 hour;
-       uint16 minute;
-       uint16 second;
-       uint16 milliseconds;
-}
-SYSTEMTIME;
-
 #endif /* _RPC_MISC_H */

diff --git a/source3/include/rpc_perfcount.h b/source3/include/rpc_perfcount.h
deleted file mode 100644 (file)
index 0cb2fdc..0000000
--- a/source3/include/rpc_perfcount.h
+++ /dev/null
@@ -1,126 +0,0 @@
-#ifndef _RPC_PERFCOUNT_H
-#define _RPC_PERFCOUNT_H
-/* 
- *  Unix SMB/CIFS implementation.
- *  Virtual Windows Registry Layer
- *
- *  Copyright (C) Marcin Krzysztof Porwit    2005,
- *  Copyright (C) Gerald (Jerry) Carter      2005.
- *  
- *  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/>.
- */
-
-typedef struct perf_counter_definition
-{
-       /* sizeof(PERF_COUNTER_DEFINITION) */
-       uint32 ByteLength;
-       uint32 CounterNameTitleIndex;
-       uint32 CounterNameTitlePointer;
-       uint32 CounterHelpTitleIndex;
-       uint32 CounterHelpTitlePointer;
-       uint32 DefaultScale;
-       uint32 DetailLevel;
-       uint32 CounterType;
-       uint32 CounterSize;
-       uint32 CounterOffset;
-}
-PERF_COUNTER_DEFINITION;
-
-typedef struct perf_counter_block
-{
-       /* Total size of the data block, including all data plus this header */
-       uint32 ByteLength;
-       uint8 *data;
-}
-PERF_COUNTER_BLOCK;
-
-typedef struct perf_instance_definition
-{
-       /* Total size of the instance definition, including the length of the terminated Name string */
-       uint32 ByteLength;
-       uint32 ParentObjectTitleIndex;
-       uint32 ParentObjectTitlePointer;
-       uint32 UniqueID;
-       /* From the start of the PERF_INSTANCE_DEFINITION, the byte offset to the start of the Name string */
-       uint32 NameOffset;
-       uint32 NameLength;
-       /* Unicode string containing the name for the instance */
-       uint8 *data;
-       PERF_COUNTER_BLOCK counter_data;
-}
-PERF_INSTANCE_DEFINITION;
-
-typedef struct perf_object_type
-{
-       /* Total size of the object block, including all PERF_INSTANCE_DEFINITIONs,
-          PERF_COUNTER_DEFINITIONs and PERF_COUNTER_BLOCKs in bytes */
-       uint32 TotalByteLength;
-       /* Size of this PERF_OBJECT_TYPE plus all PERF_COUNTER_DEFINITIONs in bytes */
-       uint32 DefinitionLength;
-       /* Size of this PERF_OBJECT_TYPE */
-       uint32 HeaderLength;
-       uint32 ObjectNameTitleIndex;
-       uint32 ObjectNameTitlePointer;
-       uint32 ObjectHelpTitleIndex;
-       uint32 ObjectHelpTitlePointer;
-       uint32 DetailLevel;
-       uint32 NumCounters;
-       uint32 DefaultCounter;
-       uint32 NumInstances;
-       uint32 CodePage;
-       uint64 PerfTime;
-       uint64 PerfFreq;
-       PERF_COUNTER_DEFINITION *counters;
-       PERF_INSTANCE_DEFINITION *instances;
-       PERF_COUNTER_BLOCK counter_data;
-}
-PERF_OBJECT_TYPE;
-
-/* PerfCounter Inner Buffer structs */
-typedef struct perf_data_block
-{
-       /* hardcoded to read "P.E.R.F" */
-       uint16 Signature[4];
-       uint32 LittleEndian;
-       /* both currently hardcoded to 1 */
-       uint32 Version;
-       uint32 Revision;
-       /* bytes of PERF_OBJECT_TYPE data, does NOT include the PERF_DATA_BLOCK */
-       uint32 TotalByteLength;
-       /* size of PERF_DATA_BLOCK including the uint8 *data */
-       uint32 HeaderLength;
-       /* number of PERF_OBJECT_TYPE structures encoded */
-       uint32 NumObjectTypes;
-       uint32 DefaultObject;
-       SYSTEMTIME SystemTime;
-       /* This will guarantee that we're on a 64-bit boundary before we encode
-          PerfTime, and having it there will make my offset math much easier. */
-       uint32 Padding;
-       /* Now when I'm marshalling this, I'll need to call prs_align_uint64() 
-          before I start encodint the uint64 structs */
-       /* clock rate * seconds uptime */
-       uint64 PerfTime;
-       /* The clock rate of the CPU */
-       uint64 PerfFreq; 
-       /* used for high-res timers -- for now PerfTime * 10e7 */
-       uint64 PerfTime100nSec;
-       uint32 SystemNameLength;
-       uint32 SystemNameOffset;
-       /* The SystemName, in unicode, terminated */
-       uint8* data;
-       PERF_OBJECT_TYPE *objects;
-} 
-PERF_DATA_BLOCK;
-
-#endif /* _RPC_PERFCOUNT_H */

diff --git a/source3/include/rpc_perfcount_defs.h b/source3/include/rpc_perfcount_defs.h
deleted file mode 100644 (file)
index 6c84c27..0000000
--- a/source3/include/rpc_perfcount_defs.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef _RPC_PERFCOUNT_DEFS_H
-#define _RPC_PERFCOUNT_DEFS_H
-/* 
- *  Unix SMB/CIFS implementation.
- *  Virtual Windows Registry Layer
- *
- *  Copyright (C) Marcin Krzysztof Porwit    2005,
- *  Copyright (C) Gerald (Jerry) Carter      2005.
- *  
- *  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/>.
- */
-
-/*
- * The following #defines match what is in winperf.h. 
- * See that include file for more details, or look up
- * "Performance Data Format" on MSDN
- * 
- * Rather than including them in rpc_perfcount.h, they
- * were broken out into a separate .h file so that they
- * can be included by other programs that need this info
- * without pulling in everything else samba-related.
- */
-
-#define PERF_NO_INSTANCES             -1
-#define PERF_NO_UNIQUE_ID            -1
-
-/* These determine the data size */
-#define PERF_SIZE_DWORD               0x00000000
-#define PERF_SIZE_LARGE               0x00000100
-#define PERF_SIZE_ZERO                0x00000200
-#define PERF_SIZE_VARIABLE_LEN        0x00000300
-
-/* These determine the usage of the counter */
-#define PERF_TYPE_NUMBER              0x00000000
-#define PERF_TYPE_COUNTER             0x00000400
-#define PERF_TYPE_TEXT                0x00000800
-#define PERF_TYPE_ZERO                0x00000C00
-
-/* If PERF_TYPE_NUMBER was selected, these provide display information */
-#define PERF_NUMBER_HEX               0x00000000
-#define PERF_NUMBER_DECIMAL           0x00010000
-#define PERF_NUMBER_DEC_1000          0x00020000
-
-/* If PERF_TYPE_COUNTER was selected, these provide display information */
-#define PERF_COUNTER_VALUE            0x00000000
-#define PERF_COUNTER_RATE             0x00010000
-#define PERF_COUNTER_FRACTION         0x00020000
-#define PERF_COUNTER_BASE             0x00030000
-#define PERF_COUNTER_ELAPSED          0x00040000
-#define PERF_COUNTER_QUEUELEN         0x00050000
-#define PERF_COUNTER_HISTOGRAM        0x00060000
-#define PERF_COUNTER_PRECISION        0x00070000
-
-/* If PERF_TYPE_TEXT was selected, these provide display information */
-#define PERF_TEXT_UNICODE             0x00000000
-#define PERF_TEXT_ASCII               0x00010000
-
-/* These provide information for which tick count to use when computing elapsed interval */
-#define PERF_TIMER_TICK               0x00000000
-#define PERF_TIMER_100NS              0x00100000
-#define PERF_OBJECT_TIMER             0x00200000
-
-/* These affect how the data is manipulated prior to being displayed */
-#define PERF_DELTA_COUNTER            0x00400000
-#define PERF_DELTA_BASE               0x00800000
-#define PERF_INVERSE_COUNTER          0x01000000
-#define PERF_MULTI_COUNTER            0x02000000
-
-/* These determine if any text gets added when the value is displayed */
-#define PERF_DISPLAY_NO_SUFFIX        0x00000000
-#define PERF_DISPLAY_PER_SEC          0x10000000
-#define PERF_DISPLAY_PERCENT          0x20000000
-#define PERF_DISPLAY_SECONDS          0x30000000
-#define PERF_DISPLAY_NOSHOW           0x40000000
-
-/* These determine the DetailLevel of the counter */
-#define PERF_DETAIL_NOVICE            100
-#define PERF_DETAIL_ADVANCED          200
-#define PERF_DETAIL_EXPERT            300
-#define PERF_DETAIL_WIZARD            400
-
-#endif /* _RPC_PERFCOUNT_DEFS_H */

diff --git a/source3/include/smb.h b/source3/include/smb.h
index 3c3ced6baf713785d495132487134844df912b57..cee95a9b170bfffb2d6368dbfa1ee8438fa493ed 100644 (file)
--- a/source3/include/smb.h
+++ b/source3/include/smb.h
@@ -727,6 +727,7 @@ struct pending_message_list {
        struct smb_perfcount_data pcd;
        uint32_t seqnum;
        bool encrypted;
+       bool processed;
        DATA_BLOB buf;
        DATA_BLOB private_data;
 };

diff --git a/source3/include/vfs.h b/source3/include/vfs.h
index ed49d1fd28f490e8532009f05bce37aa67d9f825..f9c1f0a54f20840b39a12e17a40bc1f4decf2c83 100644 (file)
--- a/source3/include/vfs.h
+++ b/source3/include/vfs.h
@@ -247,7 +247,8 @@ struct vfs_fn_pointers {
                      struct smb_file_time *ft);
        int (*ftruncate)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset);
        bool (*lock)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
-       int (*kernel_flock)(struct vfs_handle_struct *handle, struct files_struct *fsp, uint32 share_mode);
+       int (*kernel_flock)(struct vfs_handle_struct *handle, struct files_struct *fsp,
+                           uint32 share_mode, uint32_t access_mask);
        int (*linux_setlease)(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype);
        bool (*getlock)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid);
        int (*symlink)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath);
@@ -598,7 +599,8 @@ bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
                       struct files_struct *fsp, int op, SMB_OFF_T offset,
                       SMB_OFF_T count, int type);
 int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
-                             struct files_struct *fsp, uint32 share_mode);
+                             struct files_struct *fsp, uint32 share_mode,
+                             uint32_t access_mask);
 int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,
                                struct files_struct *fsp, int leasetype);
 bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,

diff --git a/source3/include/vfs_macros.h b/source3/include/vfs_macros.h
index 8ca7f373bf71e51ea68aa9d6fb150cb69b111187..7206bf41bb700799af7ba220058e16b2a5b2154d 100644 (file)
--- a/source3/include/vfs_macros.h
+++ b/source3/include/vfs_macros.h
@@ -250,10 +250,10 @@
 #define SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type) \
        smb_vfs_call_lock((handle)->next, (fsp), (op), (offset), (count), (type))
 
-#define SMB_VFS_KERNEL_FLOCK(fsp, share_mode) \
-       smb_vfs_call_kernel_flock((fsp)->conn->vfs_handles, (fsp), (share_mode))
-#define SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode) \
-       smb_vfs_call_kernel_flock((handle)->next, (fsp), (share_mode))
+#define SMB_VFS_KERNEL_FLOCK(fsp, share_mode, access_mask) \
+       smb_vfs_call_kernel_flock((fsp)->conn->vfs_handles, (fsp), (share_mode), (access_mask))
+#define SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask)        \
+       smb_vfs_call_kernel_flock((handle)->next, (fsp), (share_mode), (access_mask))
 
 #define SMB_VFS_LINUX_SETLEASE(fsp, leasetype) \
        smb_vfs_call_linux_setlease((fsp)->conn->vfs_handles, (fsp), (leasetype))

diff --git a/source3/lib/ldb/ldb_tdb/ldb_tdb.h b/source3/lib/ldb/ldb_tdb/ldb_tdb.h
index 486d948fa0ed766974d93d809ccc47f6ecbc0d05..caf8ba8d0c2826cf395dc25dc5e57f6d3c854260 100644 (file)
--- a/source3/lib/ldb/ldb_tdb/ldb_tdb.h
+++ b/source3/lib/ldb/ldb_tdb/ldb_tdb.h
@@ -3,13 +3,7 @@
 #include "system/filesys.h"
 #endif
 
-#if (_SAMBA_BUILD_ >= 4)
-#include "lib/tdb/include/tdb.h"
-#elif defined(_SAMBA_BUILD_)
-#include "../tdb/include/tdb.h"
-#else
 #include "tdb.h"
-#endif
 
 /* this private structure is used by the ltdb backend in the
    ldb_context */

diff --git a/source3/lib/netapi/examples/Makefile.in b/source3/lib/netapi/examples/Makefile.in
index 2a99f5744a2c25b8d3b27c265a1bdfe6a59b843f..4e921b65550271d818aa7d54869826a831171671 100644 (file)
--- a/source3/lib/netapi/examples/Makefile.in
+++ b/source3/lib/netapi/examples/Makefile.in
@@ -65,7 +65,10 @@ PROGS = bin/getdc@EXEEXT@ \
        bin/file_getinfo@EXEEXT@ \
        bin/file_enum@EXEEXT@ \
        bin/shutdown_init@EXEEXT@ \
-       bin/shutdown_abort@EXEEXT@
+       bin/shutdown_abort@EXEEXT@ \
+       bin/netlogon_control@EXEEXT@ \
+       bin/netlogon_control2@EXEEXT@ \
+       bin/nltest@EXEEXT@
 
 all: $(PROGS)
 
@@ -143,6 +146,9 @@ FILEGETINFO_OBJ = file/file_getinfo.o $(CMDLINE_OBJ)
 FILEENUM_OBJ = file/file_enum.o $(CMDLINE_OBJ)
 SHUTDOWNINIT_OBJ = shutdown/shutdown_init.o $(CMDLINE_OBJ)
 SHUTDOWNABORT_OBJ = shutdown/shutdown_abort.o $(CMDLINE_OBJ)
+NETLOGONCONTROL_OBJ = netlogon/netlogon_control.o $(CMDLINE_OBJ)
+NETLOGONCONTROL2_OBJ = netlogon/netlogon_control2.o $(CMDLINE_OBJ)
+NLTEST_OBJ = netlogon/nltest.o $(CMDLINE_OBJ)
 
 bin/getdc@EXEEXT@: $(BINARY_PREREQS) $(GETDC_OBJ)
        @echo Linking $@
@@ -340,6 +346,18 @@ bin/shutdown_abort@EXEEXT@: $(BINARY_PREREQS) $(SHUTDOWNABORT_OBJ)
        @echo Linking $@
        @$(CC) $(CCFLAGS) -o $@ $(SHUTDOWNABORT_OBJ) $(LDFLAGS) $(DYNEXP) $(CMDLINE_LIBS)
 
+bin/netlogon_control@EXEEXT@: $(BINARY_PREREQS) $(NETLOGONCONTROL_OBJ)
+       @echo Linking $@
+       @$(CC) $(CCFLAGS) -o $@ $(NETLOGONCONTROL_OBJ) $(LDFLAGS) $(DYNEXP) $(CMDLINE_LIBS)
+
+bin/netlogon_control2@EXEEXT@: $(BINARY_PREREQS) $(NETLOGONCONTROL2_OBJ)
+       @echo Linking $@
+       @$(CC) $(CCFLAGS) -o $@ $(NETLOGONCONTROL2_OBJ) $(LDFLAGS) $(DYNEXP) $(CMDLINE_LIBS)
+
+bin/nltest@EXEEXT@: $(BINARY_PREREQS) $(NLTEST_OBJ)
+       @echo Linking $@
+       @$(CC) $(CCFLAGS) -o $@ $(NLTEST_OBJ) $(LDFLAGS) $(DYNEXP) $(CMDLINE_LIBS)
+
 clean:
        -rm -f $(PROGS)
        -rm -f core */*~ *~ \

diff --git a/source3/lib/netapi/examples/netlogon/netlogon_control.c b/source3/lib/netapi/examples/netlogon/netlogon_control.c
new file mode 100644 (file)
index 0000000..34361cd
--- /dev/null
+++ b/source3/lib/netapi/examples/netlogon/netlogon_control.c
@@ -0,0 +1,143 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  I_NetLogonControl query
+ *  Copyright (C) Guenther Deschner 2009
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/types.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <netapi.h>
+
+#include "common.h"
+
+int main(int argc, const char **argv)
+{
+       NET_API_STATUS status;
+       struct libnetapi_ctx *ctx = NULL;
+       const char *hostname = NULL;
+       uint32_t function_code = NETLOGON_CONTROL_QUERY;
+       uint32_t level = 1;
+       uint8_t *buffer = NULL;
+       struct NETLOGON_INFO_1 *i1 = NULL;
+       struct NETLOGON_INFO_2 *i2 = NULL;
+       struct NETLOGON_INFO_3 *i3 = NULL;
+       struct NETLOGON_INFO_4 *i4 = NULL;
+
+       poptContext pc;
+       int opt;
+
+       struct poptOption long_options[] = {
+               POPT_AUTOHELP
+               POPT_COMMON_LIBNETAPI_EXAMPLES
+               POPT_TABLEEND
+       };
+
+       status = libnetapi_init(&ctx);
+       if (status != 0) {
+               return status;
+       }
+
+       pc = poptGetContext("netlogon_control", argc, argv, long_options, 0);
+
+       poptSetOtherOptionHelp(pc, "hostname");
+       while((opt = poptGetNextOpt(pc)) != -1) {
+       }
+
+       if (!poptPeekArg(pc)) {
+               poptPrintHelp(pc, stderr, 0);
+               goto out;
+       }
+       hostname = poptGetArg(pc);
+
+       if (poptPeekArg(pc)) {
+               function_code = atoi(poptGetArg(pc));
+       }
+
+       if (poptPeekArg(pc)) {
+               level = atoi(poptGetArg(pc));
+       }
+
+       /* I_NetLogonControl */
+
+       status = I_NetLogonControl(hostname,
+                                  function_code,
+                                  level,
+                                  &buffer);
+       if (status != 0) {
+               printf("I_NetLogonControl failed with: %s\n",
+                       libnetapi_get_error_string(ctx, status));
+               goto out;
+       }
+
+       if (!buffer) {
+               goto out;
+       }
+
+       switch (level) {
+       case 1:
+               i1 = (struct NETLOGON_INFO_1 *)buffer;
+
+               printf("Flags: %x\n", i1->netlog1_flags);
+               printf("Connection Status Status = %d 0x%x %s\n",
+                       i1->netlog1_pdc_connection_status,
+                       i1->netlog1_pdc_connection_status,
+                       libnetapi_errstr(i1->netlog1_pdc_connection_status));
+
+               break;
+       case 2:
+               i2 = (struct NETLOGON_INFO_2 *)buffer;
+
+               printf("Flags: %x\n", i2->netlog2_flags);
+               printf("Trusted DC Name %s\n", i2->netlog2_trusted_dc_name);
+               printf("Trusted DC Connection Status Status = %d 0x%x %s\n",
+                       i2->netlog2_tc_connection_status,
+                       i2->netlog2_tc_connection_status,
+                       libnetapi_errstr(i2->netlog2_tc_connection_status));
+               printf("Trust Verification Status Status = %d 0x%x %s\n",
+                       i2->netlog2_pdc_connection_status,
+                       i2->netlog2_pdc_connection_status,
+                       libnetapi_errstr(i2->netlog2_pdc_connection_status));
+
+               break;
+       case 3:
+               i3 = (struct NETLOGON_INFO_3 *)buffer;
+
+               printf("Flags: %x\n", i3->netlog1_flags);
+               printf("Logon Attempts: %d\n", i3->netlog3_logon_attempts);
+
+               break;
+       case 4:
+               i4 = (struct NETLOGON_INFO_4 *)buffer;
+
+               printf("Trusted DC Name %s\n", i4->netlog4_trusted_dc_name);
+               printf("Trusted Domain Name %s\n", i4->netlog4_trusted_domain_name);
+
+               break;
+       default:
+               break;
+       }
+
+ out:
+       NetApiBufferFree(buffer);
+       libnetapi_free(ctx);
+       poptFreeContext(pc);
+
+       return status;
+}

diff --git a/source3/lib/netapi/examples/netlogon/netlogon_control2.c b/source3/lib/netapi/examples/netlogon/netlogon_control2.c
new file mode 100644 (file)
index 0000000..ea8e8c2
--- /dev/null
+++ b/source3/lib/netapi/examples/netlogon/netlogon_control2.c
@@ -0,0 +1,147 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  I_NetLogonControl2 query
+ *  Copyright (C) Guenther Deschner 2009
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/types.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <netapi.h>
+
+#include "common.h"
+
+int main(int argc, const char **argv)
+{
+       NET_API_STATUS status;
+       struct libnetapi_ctx *ctx = NULL;
+       const char *hostname = NULL;
+       uint32_t function_code = NETLOGON_CONTROL_QUERY;
+       uint32_t level = 1;
+       uint8_t *buffer = NULL;
+       struct NETLOGON_INFO_1 *i1 = NULL;
+       struct NETLOGON_INFO_2 *i2 = NULL;
+       struct NETLOGON_INFO_3 *i3 = NULL;
+       struct NETLOGON_INFO_4 *i4 = NULL;
+       const char *domain = NULL;
+
+       poptContext pc;
+       int opt;
+
+       struct poptOption long_options[] = {
+               POPT_AUTOHELP
+               POPT_COMMON_LIBNETAPI_EXAMPLES
+               POPT_TABLEEND
+       };
+
+       status = libnetapi_init(&ctx);
+       if (status != 0) {
+               return status;
+       }
+
+       pc = poptGetContext("netlogon_control", argc, argv, long_options, 0);
+
+       poptSetOtherOptionHelp(pc, "hostname");
+       while((opt = poptGetNextOpt(pc)) != -1) {
+       }
+
+       if (!poptPeekArg(pc)) {
+               poptPrintHelp(pc, stderr, 0);
+               goto out;
+       }
+       hostname = poptGetArg(pc);
+
+       if (poptPeekArg(pc)) {
+               function_code = atoi(poptGetArg(pc));
+       }
+
+       if (poptPeekArg(pc)) {
+               level = atoi(poptGetArg(pc));
+       }
+
+       domain = "TEST";
+
+       /* I_NetLogonControl2 */
+
+       status = I_NetLogonControl2(hostname,
+                                   function_code,
+                                   level,
+                                   (uint8_t *)domain,
+                                   &buffer);
+       if (status != 0) {
+               printf("I_NetLogonControl2 failed with: %s\n",
+                       libnetapi_get_error_string(ctx, status));
+               goto out;
+       }
+
+       if (!buffer) {
+               goto out;
+       }
+
+       switch (level) {
+       case 1:
+               i1 = (struct NETLOGON_INFO_1 *)buffer;
+
+               printf("Flags: %x\n", i1->netlog1_flags);
+               printf("Connection Status Status = %d 0x%x %s\n",
+                       i1->netlog1_pdc_connection_status,
+                       i1->netlog1_pdc_connection_status,
+                       libnetapi_errstr(i1->netlog1_pdc_connection_status));
+
+               break;
+       case 2:
+               i2 = (struct NETLOGON_INFO_2 *)buffer;
+
+               printf("Flags: %x\n", i2->netlog2_flags);
+               printf("Trusted DC Name %s\n", i2->netlog2_trusted_dc_name);
+               printf("Trusted DC Connection Status Status = %d 0x%x %s\n",
+                       i2->netlog2_tc_connection_status,
+                       i2->netlog2_tc_connection_status,
+                       libnetapi_errstr(i2->netlog2_tc_connection_status));
+               printf("Trust Verification Status Status = %d 0x%x %s\n",
+                       i2->netlog2_pdc_connection_status,
+                       i2->netlog2_pdc_connection_status,
+                       libnetapi_errstr(i2->netlog2_pdc_connection_status));
+
+               break;
+       case 3:
+               i3 = (struct NETLOGON_INFO_3 *)buffer;
+
+               printf("Flags: %x\n", i3->netlog1_flags);
+               printf("Logon Attempts: %d\n", i3->netlog3_logon_attempts);
+
+               break;
+       case 4:
+               i4 = (struct NETLOGON_INFO_4 *)buffer;
+
+               printf("Trusted DC Name %s\n", i4->netlog4_trusted_dc_name);
+               printf("Trusted Domain Name %s\n", i4->netlog4_trusted_domain_name);
+
+               break;
+       default:
+               break;
+       }
+
+ out:
+       NetApiBufferFree(buffer);
+       libnetapi_free(ctx);
+       poptFreeContext(pc);
+
+       return status;
+}

diff --git a/source3/lib/netapi/examples/netlogon/nltest.c b/source3/lib/netapi/examples/netlogon/nltest.c
new file mode 100644 (file)
index 0000000..a9fe6de
--- /dev/null
+++ b/source3/lib/netapi/examples/netlogon/nltest.c
@@ -0,0 +1,251 @@
+/*
+ * Samba Unix/Linux SMB client library
+ * Distributed SMB/CIFS Server Management Utility
+ * Nltest netlogon testing tool
+ *
+ * Copyright (C) Guenther Deschner 2009
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/types.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <netapi.h>
+
+#include "common.h"
+
+enum {
+       OPT_DBFLAG = 1,
+       OPT_SC_QUERY,
+       OPT_SC_RESET,
+       OPT_SC_VERIFY,
+       OPT_SC_CHANGE_PWD
+};
+
+/****************************************************************
+****************************************************************/
+
+static void print_result(uint32_t level,
+                        uint8_t *buffer)
+{
+       struct NETLOGON_INFO_1 *i1 = NULL;
+       struct NETLOGON_INFO_2 *i2 = NULL;
+       struct NETLOGON_INFO_3 *i3 = NULL;
+       struct NETLOGON_INFO_4 *i4 = NULL;
+
+       if (!buffer) {
+               return;
+       }
+
+       switch (level) {
+       case 1:
+               i1 = (struct NETLOGON_INFO_1 *)buffer;
+
+               printf("Flags: %x\n", i1->netlog1_flags);
+               printf("Connection Status Status = %d 0x%x %s\n",
+                       i1->netlog1_pdc_connection_status,
+                       i1->netlog1_pdc_connection_status,
+                       libnetapi_errstr(i1->netlog1_pdc_connection_status));
+
+               break;
+       case 2:
+               i2 = (struct NETLOGON_INFO_2 *)buffer;
+
+               printf("Flags: %x\n", i2->netlog2_flags);
+               printf("Trusted DC Name %s\n", i2->netlog2_trusted_dc_name);
+               printf("Trusted DC Connection Status Status = %d 0x%x %s\n",
+                       i2->netlog2_tc_connection_status,
+                       i2->netlog2_tc_connection_status,
+                       libnetapi_errstr(i2->netlog2_tc_connection_status));
+               printf("Trust Verification Status Status = %d 0x%x %s\n",
+                       i2->netlog2_pdc_connection_status,
+                       i2->netlog2_pdc_connection_status,
+                       libnetapi_errstr(i2->netlog2_pdc_connection_status));
+
+               break;
+       case 3:
+               i3 = (struct NETLOGON_INFO_3 *)buffer;
+
+               printf("Flags: %x\n", i3->netlog1_flags);
+               printf("Logon Attempts: %d\n", i3->netlog3_logon_attempts);
+
+               break;
+       case 4:
+               i4 = (struct NETLOGON_INFO_4 *)buffer;
+
+               printf("Trusted DC Name %s\n", i4->netlog4_trusted_dc_name);
+               printf("Trusted Domain Name %s\n", i4->netlog4_trusted_domain_name);
+
+               break;
+       default:
+               break;
+       }
+}
+
+/****************************************************************
+****************************************************************/
+
+int main(int argc, const char **argv)
+{
+       int opt;
+       NET_API_STATUS status;
+       struct libnetapi_ctx *ctx = NULL;
+       const char *server_name = NULL;
+       char *opt_domain = NULL;
+       int opt_dbflag = 0;
+       uint32_t query_level;
+       uint8_t *buffer = NULL;
+
+       poptContext pc;
+       struct poptOption long_options[] = {
+               POPT_AUTOHELP
+               {"dbflag", 0, POPT_ARG_INT,   &opt_dbflag, OPT_DBFLAG, "New Debug Flag", "HEXFLAGS"},
+               {"sc_query", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_QUERY, "Query secure channel for domain on server", "DOMAIN"},
+               {"sc_reset", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_RESET, "Reset secure channel for domain on server to dcname", "DOMAIN"},
+               {"sc_verify", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_VERIFY, "Verify secure channel for domain on server", "DOMAIN"},
+               {"sc_change_pwd", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_CHANGE_PWD, "Change a secure channel password for domain on server", "DOMAIN"},
+               POPT_COMMON_LIBNETAPI_EXAMPLES
+               POPT_TABLEEND
+       };
+
+       status = libnetapi_init(&ctx);
+       if (status != 0) {
+               return status;
+       }
+
+       pc = poptGetContext("nltest", argc, argv, long_options, 0);
+
+       poptSetOtherOptionHelp(pc, "server_name");
+       while((opt = poptGetNextOpt(pc)) != -1) {
+       }
+
+       if (!poptPeekArg(pc)) {
+               poptPrintHelp(pc, stderr, 0);
+               goto done;
+       }
+       server_name = poptGetArg(pc);
+
+       if (argc == 1) {
+               poptPrintHelp(pc, stderr, 0);
+               goto done;
+       }
+
+       if (!server_name || poptGetArg(pc)) {
+               poptPrintHelp(pc, stderr, 0);
+               goto done;
+       }
+
+       if ((server_name[0] == '/' && server_name[1] == '/') ||
+           (server_name[0] == '\\' && server_name[1] ==  '\\')) {
+               server_name += 2;
+       }
+
+       poptResetContext(pc);
+
+       while ((opt = poptGetNextOpt(pc)) != -1) {
+               switch (opt) {
+
+               case OPT_DBFLAG:
+                       query_level = 1;
+                       status = I_NetLogonControl2(server_name,
+                                                   NETLOGON_CONTROL_SET_DBFLAG,
+                                                   query_level,
+                                                   (uint8_t *)opt_dbflag,
+                                                   &buffer);
+                       if (status != 0) {
+                               fprintf(stderr, "I_NetlogonControl failed: Status = %d 0x%x %s\n",
+                                       status, status,
+                                       libnetapi_get_error_string(ctx, status));
+                               goto done;
+                       }
+                       break;
+               case OPT_SC_QUERY:
+                       query_level = 2;
+                       status = I_NetLogonControl2(server_name,
+                                                   NETLOGON_CONTROL_TC_QUERY,
+                                                   query_level,
+                                                   (uint8_t *)opt_domain,
+                                                   &buffer);
+                       if (status != 0) {
+                               fprintf(stderr, "I_NetlogonControl failed: Status = %d 0x%x %s\n",
+                                       status, status,
+                                       libnetapi_get_error_string(ctx, status));
+                               goto done;
+                       }
+                       break;
+               case OPT_SC_VERIFY:
+                       query_level = 2;
+                       status = I_NetLogonControl2(server_name,
+                                                   NETLOGON_CONTROL_TC_VERIFY,
+                                                   query_level,
+                                                   (uint8_t *)opt_domain,
+                                                   &buffer);
+                       if (status != 0) {
+                               fprintf(stderr, "I_NetlogonControl failed: Status = %d 0x%x %s\n",
+                                       status, status,
+                                       libnetapi_get_error_string(ctx, status));
+                               goto done;
+                       }
+                       break;
+               case OPT_SC_RESET:
+                       query_level = 2;
+                       status = I_NetLogonControl2(server_name,
+                                                   NETLOGON_CONTROL_REDISCOVER,
+                                                   query_level,
+                                                   (uint8_t *)opt_domain,
+                                                   &buffer);
+                       if (status != 0) {
+                               fprintf(stderr, "I_NetlogonControl failed: Status = %d 0x%x %s\n",
+                                       status, status,
+                                       libnetapi_get_error_string(ctx, status));
+                               goto done;
+                       }
+                       break;
+               case OPT_SC_CHANGE_PWD:
+                       query_level = 1;
+                       status = I_NetLogonControl2(server_name,
+                                                   NETLOGON_CONTROL_CHANGE_PASSWORD,
+                                                   query_level,
+                                                   (uint8_t *)opt_domain,
+                                                   &buffer);
+                       if (status != 0) {
+                               fprintf(stderr, "I_NetlogonControl failed: Status = %d 0x%x %s\n",
+                                       status, status,
+                                       libnetapi_get_error_string(ctx, status));
+                               goto done;
+                       }
+                       break;
+               default:
+                       poptPrintHelp(pc, stderr, 0);
+                       goto done;
+               }
+       }
+
+       print_result(query_level, buffer);
+
+       printf("The command completed successfully\n");
+       status = 0;
+
+ done:
+
+       printf("\n");
+       libnetapi_free(ctx);
+       poptFreeContext(pc);
+
+       return status;
+}

diff --git a/source3/lib/netapi/group.c b/source3/lib/netapi/group.c
index 004fd3aff6f08feddf25208a33d472e4bed808f1..77ed2e84854377e45c5d71ca08e077ba1d2bf044 100644 (file)
--- a/source3/lib/netapi/group.c
+++ b/source3/lib/netapi/group.c
@@ -784,12 +784,12 @@ WERROR NetGroupAddUser_r(struct libnetapi_ctx *ctx,
                                         &rids,
                                         &types);
        if (!NT_STATUS_IS_OK(status)) {
-               werr = WERR_GROUP_NOT_FOUND;
+               werr = WERR_GROUPNOTFOUND;
                goto done;
        }
 
        if (types.ids[0] != SID_NAME_DOM_GRP) {
-               werr = WERR_GROUP_NOT_FOUND;
+               werr = WERR_GROUPNOTFOUND;
                goto done;
        }
 
@@ -905,12 +905,12 @@ WERROR NetGroupDelUser_r(struct libnetapi_ctx *ctx,
                                         &rids,
                                         &types);
        if (!NT_STATUS_IS_OK(status)) {
-               werr = WERR_GROUP_NOT_FOUND;
+               werr = WERR_GROUPNOTFOUND;
                goto done;
        }
 
        if (types.ids[0] != SID_NAME_DOM_GRP) {
-               werr = WERR_GROUP_NOT_FOUND;
+               werr = WERR_GROUPNOTFOUND;
                goto done;
        }
 

diff --git a/source3/lib/netapi/libnetapi.c b/source3/lib/netapi/libnetapi.c
index 6e366673f1061b1b29cfc494f1be2e756010ab99..336ab26854cbc593176744fcd13e549a14d95e3e 100644 (file)
--- a/source3/lib/netapi/libnetapi.c
+++ b/source3/lib/netapi/libnetapi.c
@@ -2441,3 +2441,97 @@ NET_API_STATUS NetShutdownAbort(const char * server_name /* [in] */)
        return r.out.result;
 }
 
+/****************************************************************
+ I_NetLogonControl
+****************************************************************/
+
+NET_API_STATUS I_NetLogonControl(const char * server_name /* [in] */,
+                                uint32_t function_code /* [in] */,
+                                uint32_t query_level /* [in] */,
+                                uint8_t **buffer /* [out] [ref] */)
+{
+       struct I_NetLogonControl r;
+       struct libnetapi_ctx *ctx = NULL;
+       NET_API_STATUS status;
+       WERROR werr;
+
+       status = libnetapi_getctx(&ctx);
+       if (status != 0) {
+               return status;
+       }
+
+       /* In parameters */
+       r.in.server_name = server_name;
+       r.in.function_code = function_code;
+       r.in.query_level = query_level;
+
+       /* Out parameters */
+       r.out.buffer = buffer;
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(I_NetLogonControl, &r);
+       }
+
+       if (LIBNETAPI_LOCAL_SERVER(server_name)) {
+               werr = I_NetLogonControl_l(ctx, &r);
+       } else {
+               werr = I_NetLogonControl_r(ctx, &r);
+       }
+
+       r.out.result = W_ERROR_V(werr);
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(I_NetLogonControl, &r);
+       }
+
+       return r.out.result;
+}
+
+/****************************************************************
+ I_NetLogonControl2
+****************************************************************/
+
+NET_API_STATUS I_NetLogonControl2(const char * server_name /* [in] */,
+                                 uint32_t function_code /* [in] */,
+                                 uint32_t query_level /* [in] */,
+                                 uint8_t *data /* [in] [ref] */,
+                                 uint8_t **buffer /* [out] [ref] */)
+{
+       struct I_NetLogonControl2 r;
+       struct libnetapi_ctx *ctx = NULL;
+       NET_API_STATUS status;
+       WERROR werr;
+
+       status = libnetapi_getctx(&ctx);
+       if (status != 0) {
+               return status;
+       }
+
+       /* In parameters */
+       r.in.server_name = server_name;
+       r.in.function_code = function_code;
+       r.in.query_level = query_level;
+       r.in.data = data;
+
+       /* Out parameters */
+       r.out.buffer = buffer;
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(I_NetLogonControl2, &r);
+       }
+
+       if (LIBNETAPI_LOCAL_SERVER(server_name)) {
+               werr = I_NetLogonControl2_l(ctx, &r);
+       } else {
+               werr = I_NetLogonControl2_r(ctx, &r);
+       }
+
+       r.out.result = W_ERROR_V(werr);
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(I_NetLogonControl2, &r);
+       }
+
+       return r.out.result;
+}
+

diff --git a/source3/lib/netapi/libnetapi.h b/source3/lib/netapi/libnetapi.h
index 3eab6e61ab5ad88f8b8ae80ea8fe9a7bbc741387..2711558dbc16c833faa737bfb93e27710a80edfd 100644 (file)
--- a/source3/lib/netapi/libnetapi.h
+++ b/source3/lib/netapi/libnetapi.h
@@ -440,4 +440,21 @@ WERROR NetShutdownAbort_r(struct libnetapi_ctx *ctx,
                          struct NetShutdownAbort *r);
 WERROR NetShutdownAbort_l(struct libnetapi_ctx *ctx,
                          struct NetShutdownAbort *r);
+NET_API_STATUS I_NetLogonControl(const char * server_name /* [in] */,
+                                uint32_t function_code /* [in] */,
+                                uint32_t query_level /* [in] */,
+                                uint8_t **buffer /* [out] [ref] */);
+WERROR I_NetLogonControl_r(struct libnetapi_ctx *ctx,
+                          struct I_NetLogonControl *r);
+WERROR I_NetLogonControl_l(struct libnetapi_ctx *ctx,
+                          struct I_NetLogonControl *r);
+NET_API_STATUS I_NetLogonControl2(const char * server_name /* [in] */,
+                                 uint32_t function_code /* [in] */,
+                                 uint32_t query_level /* [in] */,
+                                 uint8_t *data /* [in] [ref] */,
+                                 uint8_t **buffer /* [out] [ref] */);
+WERROR I_NetLogonControl2_r(struct libnetapi_ctx *ctx,
+                           struct I_NetLogonControl2 *r);
+WERROR I_NetLogonControl2_l(struct libnetapi_ctx *ctx,
+                           struct I_NetLogonControl2 *r);
 #endif /* __LIBNETAPI_LIBNETAPI__ */

diff --git a/source3/lib/netapi/netapi.h b/source3/lib/netapi/netapi.h
index e3ab03eadcd2b8c522bd8d7420db5dacc3854d40..96cf225d0c7a059bf361b493aa59a1edcbbdfcfe 100644 (file)
--- a/source3/lib/netapi/netapi.h
+++ b/source3/lib/netapi/netapi.h
@@ -1,7 +1,7 @@
 /*
  *  Unix SMB/CIFS implementation.
  *  NetApi Support
- *  Copyright (C) Guenther Deschner 2007-2008
+ *  Copyright (C) Guenther Deschner 2007-2009
  *
  *  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
@@ -1257,8 +1257,56 @@ struct FILE_INFO_3 {
        const char * fi3_username;
 };
 
+struct NETLOGON_INFO_1 {
+       uint32_t netlog1_flags;
+       NET_API_STATUS netlog1_pdc_connection_status;
+};
+
+struct NETLOGON_INFO_2 {
+       uint32_t netlog2_flags;
+       NET_API_STATUS netlog2_pdc_connection_status;
+       const char * netlog2_trusted_dc_name;
+       NET_API_STATUS netlog2_tc_connection_status;
+};
+
+struct NETLOGON_INFO_3 {
+       uint32_t netlog1_flags;
+       uint32_t netlog3_logon_attempts;
+       uint32_t netlog3_reserved1;
+       uint32_t netlog3_reserved2;
+       uint32_t netlog3_reserved3;
+       uint32_t netlog3_reserved4;
+       uint32_t netlog3_reserved5;
+};
+
+struct NETLOGON_INFO_4 {
+       const char * netlog4_trusted_dc_name;
+       const char * netlog4_trusted_domain_name;
+};
+
 #endif /* _HEADER_libnetapi */
 
+#ifndef _HEADER_netlogon
+
+#define NETLOGON_CONTROL_QUERY ( 0x00000001 )
+#define NETLOGON_CONTROL_REPLICATE ( 0x00000002 )
+#define NETLOGON_CONTROL_SYNCHRONIZE ( 0x00000003 )
+#define NETLOGON_CONTROL_PDC_REPLICATE ( 0x00000004 )
+#define NETLOGON_CONTROL_REDISCOVER ( 0x00000005 )
+#define NETLOGON_CONTROL_TC_QUERY ( 0x00000006 )
+#define NETLOGON_CONTROL_TRANSPORT_NOTIFY ( 0x00000007 )
+#define NETLOGON_CONTROL_FIND_USER ( 0x00000008 )
+#define NETLOGON_CONTROL_CHANGE_PASSWORD ( 0x00000009 )
+#define NETLOGON_CONTROL_TC_VERIFY ( 0x0000000A )
+#define NETLOGON_CONTROL_FORCE_DNS_REG ( 0x0000000B )
+#define NETLOGON_CONTROL_QUERY_DNS_REG ( 0x0000000C )
+#define NETLOGON_CONTROL_BACKUP_CHANGE_LOG ( 0x0000FFFC )
+#define NETLOGON_CONTROL_TRUNCATE_LOG ( 0x0000FFFD )
+#define NETLOGON_CONTROL_SET_DBFLAG ( 0x0000FFFE )
+#define NETLOGON_CONTROL_BREAKPOINT ( 0x0000FFFF )
+
+#endif /* _HEADER_netlogon */
+
 /****************************************************************
 ****************************************************************/
 
@@ -2481,6 +2529,48 @@ NET_API_STATUS NetShutdownInit(const char * server_name /* [in] */,
 
 NET_API_STATUS NetShutdownAbort(const char * server_name /* [in] */);
 
+/************************************************************//**
+ *
+ * I_NetLogonControl
+ *
+ * @brief Control various aspects of the NETLOGON service
+ *
+ * @param[in] server_name The server name to connect to
+ * @param[in] function_code The function code to call on the server
+ * @param[in] query_level The level of the NETLOGON_INFO structure returned
+ * @param[out] buffer The returned buffer containing the NETLOGON_INFO structure
+ * @return NET_API_STATUS
+ *
+ * example netlogon/netlogon_control.c
+ ***************************************************************/
+
+NET_API_STATUS I_NetLogonControl(const char * server_name /* [in] */,
+                                uint32_t function_code /* [in] */,
+                                uint32_t query_level /* [in] */,
+                                uint8_t **buffer /* [out] [ref] */);
+
+/************************************************************//**
+ *
+ * I_NetLogonControl2
+ *
+ * @brief Control various aspects of the NETLOGON service
+ *
+ * @param[in] server_name The server name to connect to
+ * @param[in] function_code The function code to call on the server
+ * @param[in] query_level The level of the NETLOGON_INFO structure returned
+ * @param[in] data The buffer containing information related to the function code
+ * @param[out] buffer The returned buffer containing the NETLOGON_INFO structure
+ * @return NET_API_STATUS
+ *
+ * example netlogon/netlogon_control2.c
+ ***************************************************************/
+
+NET_API_STATUS I_NetLogonControl2(const char * server_name /* [in] */,
+                                 uint32_t function_code /* [in] */,
+                                 uint32_t query_level /* [in] */,
+                                 uint8_t *data /* [in] [ref] */,
+                                 uint8_t **buffer /* [out] [ref] */);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

diff --git a/source3/lib/netapi/netlogon.c b/source3/lib/netapi/netlogon.c
new file mode 100644 (file)
index 0000000..082938c
--- /dev/null
+++ b/source3/lib/netapi/netlogon.c
@@ -0,0 +1,240 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  NetApi LogonControl Support
+ *  Copyright (C) Guenther Deschner 2009
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "includes.h"
+
+#include "librpc/gen_ndr/libnetapi.h"
+#include "lib/netapi/netapi.h"
+#include "lib/netapi/netapi_private.h"
+#include "lib/netapi/libnetapi.h"
+
+static WERROR construct_data(enum netr_LogonControlCode function_code,
+                            const uint8_t *data_in,
+                            union netr_CONTROL_DATA_INFORMATION *data_out)
+{
+       switch (function_code) {
+       case NETLOGON_CONTROL_QUERY:
+       case NETLOGON_CONTROL_REDISCOVER:
+       case NETLOGON_CONTROL_TC_QUERY:
+       case NETLOGON_CONTROL_CHANGE_PASSWORD:
+       case NETLOGON_CONTROL_TC_VERIFY:
+               data_out->domain = (const char *)data_in;
+               break;
+       case NETLOGON_CONTROL_FIND_USER:
+               data_out->user = (const char *)data_in;
+               break;
+       case NETLOGON_CONTROL_SET_DBFLAG:
+               data_out->debug_level = atoi((const char *)data_in);
+               break;
+       default:
+               return WERR_INVALID_PARAM;
+       }
+
+       return WERR_OK;
+}
+
+static WERROR construct_buffer(TALLOC_CTX *mem_ctx,
+                              uint32_t level,
+                              union netr_CONTROL_QUERY_INFORMATION *q,
+                              uint8_t **buffer)
+{
+       struct NETLOGON_INFO_1 *i1;
+       struct NETLOGON_INFO_2 *i2;
+       struct NETLOGON_INFO_3 *i3;
+       struct NETLOGON_INFO_4 *i4;
+
+       if (!q) {
+               return WERR_INVALID_PARAM;
+       }
+
+       switch (level) {
+       case 1:
+               i1 = talloc(mem_ctx, struct NETLOGON_INFO_1);
+               W_ERROR_HAVE_NO_MEMORY(i1);
+
+               i1->netlog1_flags                       = q->info1->flags;
+               i1->netlog1_pdc_connection_status       = W_ERROR_V(q->info1->pdc_connection_status);
+
+               *buffer = (uint8_t *)i1;
+
+               break;
+       case 2:
+               i2 = talloc(mem_ctx, struct NETLOGON_INFO_2);
+               W_ERROR_HAVE_NO_MEMORY(i2);
+
+               i2->netlog2_flags                       = q->info2->flags;
+               i2->netlog2_pdc_connection_status       = W_ERROR_V(q->info2->pdc_connection_status);
+               i2->netlog2_trusted_dc_name             = talloc_strdup(mem_ctx, q->info2->trusted_dc_name);
+               i2->netlog2_tc_connection_status        = W_ERROR_V(q->info2->tc_connection_status);
+
+               *buffer = (uint8_t *)i2;
+
+               break;
+       case 3:
+               i3 = talloc(mem_ctx, struct NETLOGON_INFO_3);
+               W_ERROR_HAVE_NO_MEMORY(i3);
+
+               i3->netlog1_flags                       = q->info3->flags;
+               i3->netlog3_logon_attempts              = q->info3->logon_attempts;
+               i3->netlog3_reserved1                   = q->info3->unknown1;
+               i3->netlog3_reserved2                   = q->info3->unknown2;
+               i3->netlog3_reserved3                   = q->info3->unknown3;
+               i3->netlog3_reserved4                   = q->info3->unknown4;
+               i3->netlog3_reserved5                   = q->info3->unknown5;
+
+               *buffer = (uint8_t *)i3;
+
+               break;
+       case 4:
+               i4 = talloc(mem_ctx, struct NETLOGON_INFO_4);
+               W_ERROR_HAVE_NO_MEMORY(i4);
+
+               i4->netlog4_trusted_dc_name             = talloc_strdup(mem_ctx, q->info4->trusted_dc_name);
+               i4->netlog4_trusted_domain_name         = talloc_strdup(mem_ctx, q->info4->trusted_domain_name);
+
+               *buffer = (uint8_t *)i4;
+
+               break;
+       default:
+               return WERR_UNKNOWN_LEVEL;
+       }
+       return WERR_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+WERROR I_NetLogonControl_r(struct libnetapi_ctx *ctx,
+                          struct I_NetLogonControl *r)
+{
+       WERROR werr;
+       NTSTATUS status;
+       struct rpc_pipe_client *pipe_cli = NULL;
+       union netr_CONTROL_QUERY_INFORMATION query;
+
+       werr = libnetapi_open_pipe(ctx, r->in.server_name,
+                                  &ndr_table_netlogon.syntax_id,
+                                  &pipe_cli);
+       if (!W_ERROR_IS_OK(werr)) {
+               goto done;
+       }
+
+       status = rpccli_netr_LogonControl(pipe_cli, ctx,
+                                         r->in.server_name,
+                                         r->in.function_code,
+                                         r->in.query_level,
+                                         &query,
+                                         &werr);
+       if (!NT_STATUS_IS_OK(status)) {
+               werr = ntstatus_to_werror(status);
+               goto done;
+       }
+
+       werr = construct_buffer(ctx, r->in.query_level, &query,
+                               r->out.buffer);
+       if (!W_ERROR_IS_OK(werr)) {
+               goto done;
+       }
+
+ done:
+       return werr;
+}
+
+/****************************************************************
+****************************************************************/
+
+WERROR I_NetLogonControl_l(struct libnetapi_ctx *ctx,
+                          struct I_NetLogonControl *r)
+{
+       LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, I_NetLogonControl);
+}
+
+/****************************************************************
+****************************************************************/
+
+WERROR I_NetLogonControl2_r(struct libnetapi_ctx *ctx,
+                           struct I_NetLogonControl2 *r)
+{
+       WERROR werr;
+       NTSTATUS status;
+       struct rpc_pipe_client *pipe_cli = NULL;
+       union netr_CONTROL_DATA_INFORMATION data;
+       union netr_CONTROL_QUERY_INFORMATION query;
+
+       werr = construct_data(r->in.function_code, r->in.data, &data);
+       if (!W_ERROR_IS_OK(werr)) {
+               goto done;
+       }
+
+       werr = libnetapi_open_pipe(ctx, r->in.server_name,
+                                  &ndr_table_netlogon.syntax_id,
+                                  &pipe_cli);
+       if (!W_ERROR_IS_OK(werr)) {
+               goto done;
+       }
+
+       switch (r->in.function_code) {
+       case NETLOGON_CONTROL_TC_VERIFY:
+       case NETLOGON_CONTROL_SET_DBFLAG:
+               status = rpccli_netr_LogonControl2Ex(pipe_cli, ctx,
+                                                    r->in.server_name,
+                                                    r->in.function_code,
+                                                    r->in.query_level,
+                                                    &data,
+                                                    &query,
+                                                    &werr);
+               break;
+       default:
+               status = rpccli_netr_LogonControl2(pipe_cli, ctx,
+                                                  r->in.server_name,
+                                                  r->in.function_code,
+                                                  r->in.query_level,
+                                                  &data,
+                                                  &query,
+                                                  &werr);
+               break;
+       }
+
+       if (!W_ERROR_IS_OK(werr)) {
+               goto done;
+       }
+
+       if (!NT_STATUS_IS_OK(status)) {
+               werr = ntstatus_to_werror(status);
+               goto done;
+       }
+
+       werr = construct_buffer(ctx, r->in.query_level, &query,
+                               r->out.buffer);
+       if (!W_ERROR_IS_OK(werr)) {
+               goto done;
+       }
+
+ done:
+       return werr;
+}
+
+/****************************************************************
+****************************************************************/
+
+WERROR I_NetLogonControl2_l(struct libnetapi_ctx *ctx,
+                           struct I_NetLogonControl2 *r)
+{
+       LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, I_NetLogonControl2);
+}

diff --git a/source3/lib/smbldap.c b/source3/lib/smbldap.c
index c96801a72b2961f6e3e3800f53e9b8d4b9391021..7287e3d9986a7698a0d40350a1eac71788edac70 100644 (file)
--- a/source3/lib/smbldap.c
+++ b/source3/lib/smbldap.c
@@ -721,9 +721,18 @@ int smb_ldap_setup_conn(LDAP **ldap_struct, const char *uri)
        rc = ldap_initialize(ldap_struct, uri);
        if (rc) {
                DEBUG(0, ("ldap_initialize: %s\n", ldap_err2string(rc)));
+               return rc;
        }
 
-       return rc;
+       if (lp_ldap_ref_follow() != Auto) {
+               rc = ldap_set_option(*ldap_struct, LDAP_OPT_REFERRALS,
+                    lp_ldap_ref_follow() ? LDAP_OPT_ON : LDAP_OPT_OFF);
+               if (rc != LDAP_SUCCESS)
+                       DEBUG(0, ("Failed to set LDAP_OPT_REFERRALS: %s\n",
+                               ldap_err2string(rc)));
+       }
+
+       return LDAP_SUCCESS;
 #else 
 
        /* Parse the string manually */
@@ -774,7 +783,6 @@ int smb_ldap_setup_conn(LDAP **ldap_struct, const char *uri)
        }
 #endif /* HAVE_LDAP_INITIALIZE */
 
-
        /* now set connection timeout */
 #ifdef LDAP_X_OPT_CONNECT_TIMEOUT /* Netscape */
        {
@@ -1046,12 +1054,18 @@ static int smbldap_connect_system(struct smbldap_state *ldap_state, LDAP * ldap_
        int version;
 
        if (!ldap_state->anonymous && !ldap_state->bind_dn) {
+               char *bind_dn = NULL;
+               char *bind_secret = NULL;
 
                /* get the default dn and password only if they are not set already */
-               if (!fetch_ldap_pw(&ldap_state->bind_dn, &ldap_state->bind_secret)) {
+               if (!fetch_ldap_pw(&bind_dn, &bind_secret)) {
                        DEBUG(0, ("ldap_connect_system: Failed to retrieve password from secrets.tdb\n"));
                        return LDAP_INVALID_CREDENTIALS;
                }
+               smbldap_set_creds(ldap_state, false, bind_dn, bind_secret);
+               SAFE_FREE(bind_dn);
+               memset(bind_secret, '\0', strlen(bind_secret));
+               SAFE_FREE(bind_secret);
        }
 
        /* removed the sasl_bind_s "EXTERNAL" stuff, as my testsuite 

diff --git a/source3/lib/system.c b/source3/lib/system.c
index 2c6894ff941cfc8cb46a2bcfd5430dee9039de03..f9cd4a2355a114a082dbe898c2ab2f072b4e7168 100644 (file)
--- a/source3/lib/system.c
+++ b/source3/lib/system.c
@@ -702,7 +702,7 @@ FILE *sys_fopen(const char *path, const char *type)
  A flock() wrapper that will perform the kernel flock.
 ********************************************************************/
 
-void kernel_flock(int fd, uint32 share_mode)
+void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
 {
 #if HAVE_KERNEL_SHARE_MODES
        int kernel_mode = 0;

diff --git a/source3/lib/util_reg.c b/source3/lib/util_reg.c
index 1e1bcfeb10336fb2fc70d6aa2567b7504329d14d..ca46f86f6980105639d4b4a60436089c782c3796 100644 (file)
--- a/source3/lib/util_reg.c
+++ b/source3/lib/util_reg.c
@@ -18,6 +18,7 @@
  */
 
 #include "includes.h"
+#include "../librpc/gen_ndr/ndr_winreg.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
@@ -75,38 +76,86 @@ const char *reg_type_lookup(enum winreg_Type type)
 WERROR reg_pull_multi_sz(TALLOC_CTX *mem_ctx, const void *buf, size_t len,
                         uint32 *num_values, char ***values)
 {
-       const smb_ucs2_t *p = (const smb_ucs2_t *)buf;
-       *num_values = 0;
+       DATA_BLOB blob;
+       const char **vals;
+       int i;
 
-       /*
-        * Make sure that a talloc context for the strings retrieved exists
-        */
+       blob = data_blob_const((uint8_t *)buf, len);
 
-       if (!(*values = TALLOC_ARRAY(mem_ctx, char *, 1))) {
+       if (!pull_reg_multi_sz(mem_ctx, &blob, &vals)) {
                return WERR_NOMEM;
        }
 
-       len /= 2;               /* buf is a set of UCS2 strings */
+       for (i=0; vals[i]; i++) {
+               ;;
+       }
 
-       while (len > 0) {
-               char *val;
-               size_t dstlen, thislen;
+       *num_values = i;
+       *values = (char **)vals;
 
-               thislen = strnlen_w(p, len) + 1;
-               if (!convert_string_talloc(*values, CH_UTF16LE, CH_UNIX,
-                       p, thislen*2, (void *)&val, &dstlen, true)) {
-                       TALLOC_FREE(*values);
-                       return WERR_NOMEM;
-               }
+       return WERR_OK;
+}
 
-               ADD_TO_ARRAY(*values, char *, val, values, num_values);
-               if (*values == NULL) {
-                       return WERR_NOMEM;
-               }
+/*******************************************************************
+ push a string in unix charset into a REG_SZ UCS2 null terminated blob
+ ********************************************************************/
 
-               p += thislen;
-               len -= thislen;
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s)
+{
+       union winreg_Data data;
+       enum ndr_err_code ndr_err;
+       data.string = s;
+       ndr_err = ndr_push_union_blob(blob, mem_ctx, NULL, &data, REG_SZ,
+                       (ndr_push_flags_fn_t)ndr_push_winreg_Data);
+       return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
+}
+
+/*******************************************************************
+ push a string_array in unix charset into a REG_MULTI_SZ UCS2 double-null
+ terminated blob
+ ********************************************************************/
+
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a)
+{
+       union winreg_Data data;
+       enum ndr_err_code ndr_err;
+       data.string_array = a;
+       ndr_err = ndr_push_union_blob(blob, mem_ctx, NULL, &data, REG_MULTI_SZ,
+                       (ndr_push_flags_fn_t)ndr_push_winreg_Data);
+       return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
+}
+
+/*******************************************************************
+ pull a string in unix charset out of a REG_SZ UCS2 null terminated blob
+ ********************************************************************/
+
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s)
+{
+       union winreg_Data data;
+       enum ndr_err_code ndr_err;
+       ndr_err = ndr_pull_union_blob(blob, mem_ctx, NULL, &data, REG_SZ,
+                       (ndr_pull_flags_fn_t)ndr_pull_winreg_Data);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               return false;
        }
+       *s = data.string;
+       return true;
+}
 
-       return WERR_OK;
+/*******************************************************************
+ pull a string_array in unix charset out of a REG_MULTI_SZ UCS2 double-null
+ terminated blob
+ ********************************************************************/
+
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char ***a)
+{
+       union winreg_Data data;
+       enum ndr_err_code ndr_err;
+       ndr_err = ndr_pull_union_blob(blob, mem_ctx, NULL, &data, REG_MULTI_SZ,
+                       (ndr_pull_flags_fn_t)ndr_pull_winreg_Data);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               return false;
+       }
+       *a = data.string_array;
+       return true;
 }

diff --git a/source3/lib/util_unistr.c b/source3/lib/util_unistr.c
index 7d80b3cdea26ed396a4f308dd285630d53dcc2c3..f53ef94d69eca4b5b8c016b6c9ed75bfbe08457c 100644 (file)
--- a/source3/lib/util_unistr.c
+++ b/source3/lib/util_unistr.c
@@ -256,41 +256,6 @@ char *skip_unibuf(char *src, size_t len)
        return src;
 }
 
-/* Copy a string from little-endian or big-endian unicode source (depending
- * on flags) to internal samba format destination
- */ 
-
-int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
-{
-       if (!src) {
-               dest[0] = 0;
-               return 0;
-       }
-       if(dest_len==-1) {
-               dest_len=MAXUNI-3;
-       }
-       return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
-}
-
-/* Copy a string from little-endian or big-endian unicode source (depending
- * on flags) to internal samba format destination. Allocates on talloc ctx.
- */
-
-int rpcstr_pull_talloc(TALLOC_CTX *ctx,
-                       char **dest,
-                       void *src,
-                       int src_len,
-                       int flags)
-{
-       return pull_ucs2_base_talloc(ctx,
-                       NULL,
-                       dest,
-                       src,
-                       src_len,
-                       flags|STR_UNICODE|STR_NOALIGN);
-
-}
-
 /* Converts a string from internal samba format to unicode
  */
 

diff --git a/source3/libads/dns.c b/source3/libads/dns.c
index 0797eb1156f5f26cb892fe13bff4f74fc4a18f04..1765f95ca0e5c5ec1b20d0b9a6f5d34a956e6515 100644 (file)
--- a/source3/libads/dns.c
+++ b/source3/libads/dns.c
@@ -506,9 +506,10 @@ static NTSTATUS ads_dns_lookup_srv( TALLOC_CTX *ctx,
 
                if (rr.type != T_A || rr.rdatalen != 4) {
 #if defined(HAVE_IPV6)
-                       /* FIXME. RFC2874 defines A6 records. This
+                       /* RFC2874 defines A6 records. This
                         * requires recusive and horribly complex lookups.
                         * Bastards. Ignore this for now.... JRA.
+                        * Luckily RFC3363 reprecates A6 records.
                         */
                        if (rr.type != T_AAAA || rr.rdatalen != 16)
 #endif

diff --git a/source3/libads/util.c b/source3/libads/util.c
index 2c7ccfebd6cf53cb826123866dcf4900f9839883..9dcb906a37206c4c87dd2495566e0c5f6cd3d10c 100644 (file)
--- a/source3/libads/util.c
+++ b/source3/libads/util.c
@@ -26,7 +26,7 @@ ADS_STATUS ads_change_trust_account_password(ADS_STRUCT *ads, char *host_princip
        char *password;
        char *new_password;
        ADS_STATUS ret;
-       uint32 sec_channel_type;
+       enum netr_SchannelType sec_channel_type;
     
        if ((password = secrets_fetch_machine_password(lp_workgroup(), NULL, &sec_channel_type)) == NULL) {
                DEBUG(1,("Failed to retrieve password for principal %s\n", host_principal));

diff --git a/source3/libnet/libnet_join.c b/source3/libnet/libnet_join.c
index cd476868e302c2d6c4b57b85a2d473d6140dee4a..aa5f54adaf6035fd7bcfb3934c1a102ee51fc4c8 100644 (file)
--- a/source3/libnet/libnet_join.c
+++ b/source3/libnet/libnet_join.c
@@ -789,6 +789,7 @@ static NTSTATUS libnet_join_joindomain_rpc_unsecure(TALLOC_CTX *mem_ctx,
        E_md4hash(trust_passwd, orig_trust_passwd_hash);
 
        status = rpccli_netlogon_set_trust_password(pipe_hnd, mem_ctx,
+                                                   r->in.machine_name,
                                                    orig_trust_passwd_hash,
                                                    r->in.machine_password,
                                                    new_trust_passwd_hash,
@@ -1828,7 +1829,7 @@ static WERROR libnet_DomainJoin(TALLOC_CTX *mem_ctx,
                                "failed to find DC for domain %s",
                                r->in.domain_name,
                                get_friendly_nt_error_msg(status));
-                       return WERR_DC_NOT_FOUND;
+                       return WERR_DCNOTFOUND;
                }
 
                dc = strip_hostname(info->dc_unc);
@@ -2019,7 +2020,7 @@ static WERROR libnet_DomainUnjoin(TALLOC_CTX *mem_ctx,
                                "failed to find DC for domain %s",
                                r->in.domain_name,
                                get_friendly_nt_error_msg(status));
-                       return WERR_DC_NOT_FOUND;
+                       return WERR_DCNOTFOUND;
                }
 
                dc = strip_hostname(info->dc_unc);

diff --git a/source3/librpc/gen_ndr/cli_wbint.c b/source3/librpc/gen_ndr/cli_wbint.c
index 3e5fc441d59973cd9cfc5f219fc1a7d1ae4a42bc..ecf83631925d333c90a4f228d4898138154e89b5 100644 (file)
--- a/source3/librpc/gen_ndr/cli_wbint.c
+++ b/source3/librpc/gen_ndr/cli_wbint.c
@@ -3075,6 +3075,152 @@ NTSTATUS rpccli_wbint_CheckMachineAccount(struct rpc_pipe_client *cli,
        return r.out.result;
 }
 
+struct rpccli_wbint_ChangeMachineAccount_state {
+       struct wbint_ChangeMachineAccount orig;
+       struct wbint_ChangeMachineAccount tmp;
+       TALLOC_CTX *out_mem_ctx;
+       NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
+};
+
+static void rpccli_wbint_ChangeMachineAccount_done(struct tevent_req *subreq);
+
+struct tevent_req *rpccli_wbint_ChangeMachineAccount_send(TALLOC_CTX *mem_ctx,
+                                                         struct tevent_context *ev,
+                                                         struct rpc_pipe_client *cli)
+{
+       struct tevent_req *req;
+       struct rpccli_wbint_ChangeMachineAccount_state *state;
+       struct tevent_req *subreq;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct rpccli_wbint_ChangeMachineAccount_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->out_mem_ctx = NULL;
+       state->dispatch_recv = cli->dispatch_recv;
+
+       /* In parameters */
+
+       /* Out parameters */
+
+       /* Result */
+       ZERO_STRUCT(state->orig.out.result);
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(wbint_ChangeMachineAccount, &state->orig);
+       }
+
+       /* make a temporary copy, that we pass to the dispatch function */
+       state->tmp = state->orig;
+
+       subreq = cli->dispatch_send(state, ev, cli,
+                                   &ndr_table_wbint,
+                                   NDR_WBINT_CHANGEMACHINEACCOUNT,
+                                   &state->tmp);
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, rpccli_wbint_ChangeMachineAccount_done, req);
+       return req;
+}
+
+static void rpccli_wbint_ChangeMachineAccount_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct rpccli_wbint_ChangeMachineAccount_state *state = tevent_req_data(
+               req, struct rpccli_wbint_ChangeMachineAccount_state);
+       NTSTATUS status;
+       TALLOC_CTX *mem_ctx;
+
+       if (state->out_mem_ctx) {
+               mem_ctx = state->out_mem_ctx;
+       } else {
+               mem_ctx = state;
+       }
+
+       status = state->dispatch_recv(subreq, mem_ctx);
+       TALLOC_FREE(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       /* Copy out parameters */
+
+       /* Copy result */
+       state->orig.out.result = state->tmp.out.result;
+
+       /* Reset temporary structure */
+       ZERO_STRUCT(state->tmp);
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(wbint_ChangeMachineAccount, &state->orig);
+       }
+
+       tevent_req_done(req);
+}
+
+NTSTATUS rpccli_wbint_ChangeMachineAccount_recv(struct tevent_req *req,
+                                               TALLOC_CTX *mem_ctx,
+                                               NTSTATUS *result)
+{
+       struct rpccli_wbint_ChangeMachineAccount_state *state = tevent_req_data(
+               req, struct rpccli_wbint_ChangeMachineAccount_state);
+       NTSTATUS status;
+
+       if (tevent_req_is_nterror(req, &status)) {
+               tevent_req_received(req);
+               return status;
+       }
+
+       /* Steal possbile out parameters to the callers context */
+       talloc_steal(mem_ctx, state->out_mem_ctx);
+
+       /* Return result */
+       *result = state->orig.out.result;
+
+       tevent_req_received(req);
+       return NT_STATUS_OK;
+}
+
+NTSTATUS rpccli_wbint_ChangeMachineAccount(struct rpc_pipe_client *cli,
+                                          TALLOC_CTX *mem_ctx)
+{
+       struct wbint_ChangeMachineAccount r;
+       NTSTATUS status;
+
+       /* In parameters */
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(wbint_ChangeMachineAccount, &r);
+       }
+
+       status = cli->dispatch(cli,
+                               mem_ctx,
+                               &ndr_table_wbint,
+                               NDR_WBINT_CHANGEMACHINEACCOUNT,
+                               &r);
+
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(wbint_ChangeMachineAccount, &r);
+       }
+
+       if (NT_STATUS_IS_ERR(status)) {
+               return status;
+       }
+
+       /* Return variables */
+
+       /* Return result */
+       return r.out.result;
+}
+
 struct rpccli_wbint_SetMapping_state {
        struct wbint_SetMapping orig;
        struct wbint_SetMapping tmp;

diff --git a/source3/librpc/gen_ndr/cli_wbint.h b/source3/librpc/gen_ndr/cli_wbint.h
index 7d7c2bcdaca0938b5c29fe7798aefce59b8a5f69..b08ef3fef14af297c7ca591502c7a7fe7438deb3 100644 (file)
--- a/source3/librpc/gen_ndr/cli_wbint.h
+++ b/source3/librpc/gen_ndr/cli_wbint.h
@@ -240,6 +240,14 @@ NTSTATUS rpccli_wbint_CheckMachineAccount_recv(struct tevent_req *req,
                                               NTSTATUS *result);
 NTSTATUS rpccli_wbint_CheckMachineAccount(struct rpc_pipe_client *cli,
                                          TALLOC_CTX *mem_ctx);
+struct tevent_req *rpccli_wbint_ChangeMachineAccount_send(TALLOC_CTX *mem_ctx,
+                                                         struct tevent_context *ev,
+                                                         struct rpc_pipe_client *cli);
+NTSTATUS rpccli_wbint_ChangeMachineAccount_recv(struct tevent_req *req,
+                                               TALLOC_CTX *mem_ctx,
+                                               NTSTATUS *result);
+NTSTATUS rpccli_wbint_ChangeMachineAccount(struct rpc_pipe_client *cli,
+                                          TALLOC_CTX *mem_ctx);
 struct tevent_req *rpccli_wbint_SetMapping_send(TALLOC_CTX *mem_ctx,
                                                struct tevent_context *ev,
                                                struct rpc_pipe_client *cli,

diff --git a/source3/librpc/gen_ndr/libnetapi.h b/source3/librpc/gen_ndr/libnetapi.h
index 55d24082486918fc3780b512723ab86ca03ee5a0..83acb3aa50367c4aad2d8117864bb187ae7f5c0d 100644 (file)
--- a/source3/librpc/gen_ndr/libnetapi.h
+++ b/source3/librpc/gen_ndr/libnetapi.h
@@ -33,7 +33,7 @@
 enum NET_API_STATUS
 #ifndef USE_UINT_ENUMS
  {
-       NERR_Success=0
+       NERR_Success=(int)(0)
 }
 #else
  { __donnot_use_enum_NET_API_STATUS=0x7FFFFFFF}
@@ -65,10 +65,10 @@ struct domsid {
 enum NETSETUP_JOIN_STATUS
 #ifndef USE_UINT_ENUMS
  {
-       NetSetupUnknownStatus=0,
-       NetSetupUnjoined=1,
-       NetSetupWorkgroupName=2,
-       NetSetupDomainName=3
+       NetSetupUnknownStatus=(int)(0),
+       NetSetupUnjoined=(int)(1),
+       NetSetupWorkgroupName=(int)(2),
+       NetSetupDomainName=(int)(3)
 }
 #else
  { __donnot_use_enum_NETSETUP_JOIN_STATUS=0x7FFFFFFF}
@@ -1170,16 +1170,16 @@ struct LOCALGROUP_INFO_1002 {
 enum SID_NAME_USE
 #ifndef USE_UINT_ENUMS
  {
-       SidTypeUser=1,
-       SidTypeGroup=2,
-       SidTypeDomain=3,
-       SidTypeAlias=4,
-       SidTypeWellKnownGroup=5,
-       SidTypeDeletedAccount=6,
-       SidTypeInvalid=7,
-       SidTypeUnknown=8,
-       SidTypeComputer=9,
-       SidTypeLabel=10
+       SidTypeUser=(int)(1),
+       SidTypeGroup=(int)(2),
+       SidTypeDomain=(int)(3),
+       SidTypeAlias=(int)(4),
+       SidTypeWellKnownGroup=(int)(5),
+       SidTypeDeletedAccount=(int)(6),
+       SidTypeInvalid=(int)(7),
+       SidTypeUnknown=(int)(8),
+       SidTypeComputer=(int)(9),
+       SidTypeLabel=(int)(10)
 }
 #else
  { __donnot_use_enum_SID_NAME_USE=0x7FFFFFFF}
@@ -1295,6 +1295,33 @@ struct FILE_INFO_3 {
        const char * fi3_username;
 };
 
+struct NETLOGON_INFO_1 {
+       uint32_t netlog1_flags;
+       enum NET_API_STATUS netlog1_pdc_connection_status;
+};
+
+struct NETLOGON_INFO_2 {
+       uint32_t netlog2_flags;
+       enum NET_API_STATUS netlog2_pdc_connection_status;
+       const char * netlog2_trusted_dc_name;
+       enum NET_API_STATUS netlog2_tc_connection_status;
+};
+
+struct NETLOGON_INFO_3 {
+       uint32_t netlog1_flags;
+       uint32_t netlog3_logon_attempts;
+       uint32_t netlog3_reserved1;
+       uint32_t netlog3_reserved2;
+       uint32_t netlog3_reserved3;
+       uint32_t netlog3_reserved4;
+       uint32_t netlog3_reserved5;
+};
+
+struct NETLOGON_INFO_4 {
+       const char * netlog4_trusted_dc_name;
+       const char * netlog4_trusted_domain_name;
+};
+
 
 struct NetJoinDomain {
        struct {
@@ -2099,4 +2126,35 @@ struct NetShutdownAbort {
 
 };
 
+
+struct I_NetLogonControl {
+       struct {
+               const char * server_name;
+               uint32_t function_code;
+               uint32_t query_level;
+       } in;
+
+       struct {
+               uint8_t **buffer;/* [ref] */
+               enum NET_API_STATUS result;
+       } out;
+
+};
+
+
+struct I_NetLogonControl2 {
+       struct {
+               const char * server_name;
+               uint32_t function_code;
+               uint32_t query_level;
+               uint8_t *data;/* [ref] */
+       } in;
+
+       struct {
+               uint8_t **buffer;/* [ref] */
+               enum NET_API_STATUS result;
+       } out;
+
+};
+
 #endif /* _HEADER_libnetapi */

diff --git a/source3/librpc/gen_ndr/messaging.h b/source3/librpc/gen_ndr/messaging.h
index 79b097cc6b43279edf6449d65bcedb974e641b83..225440a8fd69c6c0d09a2c40dbae55e25c33373e 100644 (file)
--- a/source3/librpc/gen_ndr/messaging.h
+++ b/source3/librpc/gen_ndr/messaging.h
@@ -11,58 +11,58 @@
 enum messaging_type
 #ifndef USE_UINT_ENUMS
  {
-       MSG_DEBUG=(int)0x0001,
-       MSG_PING=(int)0x0002,
-       MSG_PONG=(int)0x0003,
-       MSG_PROFILE=(int)0x0004,
-       MSG_REQ_DEBUGLEVEL=(int)0x0005,
-       MSG_DEBUGLEVEL=(int)0x0006,
-       MSG_REQ_PROFILELEVEL=(int)0x0007,
-       MSG_PROFILELEVEL=(int)0x0008,
-       MSG_REQ_POOL_USAGE=(int)0x0009,
-       MSG_POOL_USAGE=(int)0x000A,
-       MSG_REQ_DMALLOC_MARK=(int)0x000B,
-       MSG_REQ_DMALLOC_LOG_CHANGED=(int)0x000C,
-       MSG_SHUTDOWN=(int)0x000D,
-       MSG_FORCE_ELECTION=(int)0x0101,
-       MSG_WINS_NEW_ENTRY=(int)0x0102,
-       MSG_SEND_PACKET=(int)0x0103,
-       MSG_PRINTER_NOTIFY=(int)0x2001,
-       MSG_PRINTER_NOTIFY2=(int)0x0202,
-       MSG_PRINTER_DRVUPGRADE=(int)0x0203,
-       MSG_PRINTERDATA_INIT_RESET=(int)0x0204,
-       MSG_PRINTER_UPDATE=(int)0x0205,
-       MSG_PRINTER_MOD=(int)0x0206,
-       MSG_SMB_CONF_UPDATED=(int)0x0301,
-       MSG_SMB_FORCE_TDIS=(int)0x0302,
-       MSG_SMB_SAM_SYNC=(int)0x0303,
-       MSG_SMB_SAM_REPL=(int)0x0304,
-       MSG_SMB_UNLOCK=(int)0x0305,
-       MSG_SMB_BREAK_REQUEST=(int)0x0306,
-       MSG_SMB_BREAK_RESPONSE=(int)0x0307,
-       MSG_SMB_ASYNC_LEVEL2_BREAK=(int)0x0308,
-       MSG_SMB_OPEN_RETRY=(int)0x0309,
-       MSG_SMB_KERNEL_BREAK=(int)0x030A,
-       MSG_SMB_FILE_RENAME=(int)0x030B,
-       MSG_SMB_INJECT_FAULT=(int)0x030C,
-       MSG_SMB_BLOCKING_LOCK_CANCEL=(int)0x030D,
-       MSG_SMB_NOTIFY=(int)0x030E,
-       MSG_SMB_STAT_CACHE_DELETE=(int)0x030F,
-       MSG_PVFS_NOTIFY=(int)0x0310,
-       MSG_SMB_BRL_VALIDATE=(int)0x0311,
-       MSG_SMB_RELEASE_IP=(int)0x0312,
-       MSG_SMB_CLOSE_FILE=(int)0x0313,
-       MSG_WINBIND_FINISHED=(int)0x0401,
-       MSG_WINBIND_FORGET_STATE=(int)0x0402,
-       MSG_WINBIND_ONLINE=(int)0x0403,
-       MSG_WINBIND_OFFLINE=(int)0x0404,
-       MSG_WINBIND_ONLINESTATUS=(int)0x0405,
-       MSG_WINBIND_TRY_TO_GO_ONLINE=(int)0x0406,
-       MSG_WINBIND_FAILED_TO_GO_ONLINE=(int)0x0407,
-       MSG_WINBIND_VALIDATE_CACHE=(int)0x0408,
-       MSG_WINBIND_DUMP_DOMAIN_LIST=(int)0x0409,
-       MSG_DUMP_EVENT_LIST=(int)0x0500,
-       MSG_DBWRAP_TDB2_CHANGES=(int)4001
+       MSG_DEBUG=(int)(0x0001),
+       MSG_PING=(int)(0x0002),
+       MSG_PONG=(int)(0x0003),
+       MSG_PROFILE=(int)(0x0004),
+       MSG_REQ_DEBUGLEVEL=(int)(0x0005),
+       MSG_DEBUGLEVEL=(int)(0x0006),
+       MSG_REQ_PROFILELEVEL=(int)(0x0007),
+       MSG_PROFILELEVEL=(int)(0x0008),
+       MSG_REQ_POOL_USAGE=(int)(0x0009),
+       MSG_POOL_USAGE=(int)(0x000A),
+       MSG_REQ_DMALLOC_MARK=(int)(0x000B),
+       MSG_REQ_DMALLOC_LOG_CHANGED=(int)(0x000C),
+       MSG_SHUTDOWN=(int)(0x000D),
+       MSG_FORCE_ELECTION=(int)(0x0101),
+       MSG_WINS_NEW_ENTRY=(int)(0x0102),
+       MSG_SEND_PACKET=(int)(0x0103),
+       MSG_PRINTER_NOTIFY=(int)(0x2001),
+       MSG_PRINTER_NOTIFY2=(int)(0x0202),
+       MSG_PRINTER_DRVUPGRADE=(int)(0x0203),
+       MSG_PRINTERDATA_INIT_RESET=(int)(0x0204),
+       MSG_PRINTER_UPDATE=(int)(0x0205),
+       MSG_PRINTER_MOD=(int)(0x0206),
+       MSG_SMB_CONF_UPDATED=(int)(0x0301),
+       MSG_SMB_FORCE_TDIS=(int)(0x0302),
+       MSG_SMB_SAM_SYNC=(int)(0x0303),
+       MSG_SMB_SAM_REPL=(int)(0x0304),
+       MSG_SMB_UNLOCK=(int)(0x0305),
+       MSG_SMB_BREAK_REQUEST=(int)(0x0306),
+       MSG_SMB_BREAK_RESPONSE=(int)(0x0307),
+       MSG_SMB_ASYNC_LEVEL2_BREAK=(int)(0x0308),
+       MSG_SMB_OPEN_RETRY=(int)(0x0309),
+       MSG_SMB_KERNEL_BREAK=(int)(0x030A),
+       MSG_SMB_FILE_RENAME=(int)(0x030B),
+       MSG_SMB_INJECT_FAULT=(int)(0x030C),
+       MSG_SMB_BLOCKING_LOCK_CANCEL=(int)(0x030D),
+       MSG_SMB_NOTIFY=(int)(0x030E),
+       MSG_SMB_STAT_CACHE_DELETE=(int)(0x030F),
+       MSG_PVFS_NOTIFY=(int)(0x0310),
+       MSG_SMB_BRL_VALIDATE=(int)(0x0311),
+       MSG_SMB_RELEASE_IP=(int)(0x0312),
+       MSG_SMB_CLOSE_FILE=(int)(0x0313),
+       MSG_WINBIND_FINISHED=(int)(0x0401),
+       MSG_WINBIND_FORGET_STATE=(int)(0x0402),
+       MSG_WINBIND_ONLINE=(int)(0x0403),
+       MSG_WINBIND_OFFLINE=(int)(0x0404),
+       MSG_WINBIND_ONLINESTATUS=(int)(0x0405),
+       MSG_WINBIND_TRY_TO_GO_ONLINE=(int)(0x0406),
+       MSG_WINBIND_FAILED_TO_GO_ONLINE=(int)(0x0407),
+       MSG_WINBIND_VALIDATE_CACHE=(int)(0x0408),
+       MSG_WINBIND_DUMP_DOMAIN_LIST=(int)(0x0409),
+       MSG_DUMP_EVENT_LIST=(int)(0x0500),
+       MSG_DBWRAP_TDB2_CHANGES=(int)(4001)
 }
 #else
  { __donnot_use_enum_messaging_type=0x7FFFFFFF}

diff --git a/source3/librpc/gen_ndr/ndr_libnetapi.c b/source3/librpc/gen_ndr/ndr_libnetapi.c
index 25956bff85d56aac2682e15dcaad596eee298eb3..2dfca23e28a9d2e836125e607603377ec73d384d 100644 (file)
--- a/source3/librpc/gen_ndr/ndr_libnetapi.c
+++ b/source3/librpc/gen_ndr/ndr_libnetapi.c
@@ -5,14 +5,14 @@
 
 _PUBLIC_ enum ndr_err_code ndr_push_NET_API_STATUS(struct ndr_push *ndr, int ndr_flags, enum NET_API_STATUS r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 _PUBLIC_ enum ndr_err_code ndr_pull_NET_API_STATUS(struct ndr_pull *ndr, int ndr_flags, enum NET_API_STATUS *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -38,6 +38,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_domsid(struct ndr_push *ndr, int ndr_flags,
                for (cntr_sub_auths_0 = 0; cntr_sub_auths_0 < MAXSUBAUTHS; cntr_sub_auths_0++) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sub_auths[cntr_sub_auths_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -60,6 +61,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_domsid(struct ndr_pull *ndr, int ndr_flags,
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sub_auths[cntr_sub_auths_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sub_auths_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -126,6 +128,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_100(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv100_platform_id));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sv100_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -138,6 +141,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_100(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv100_platform_id));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sv100_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -163,6 +167,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_101(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv101_version_minor));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv101_type));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sv101_comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -179,6 +184,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_101(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv101_version_minor));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv101_type));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sv101_comment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -215,6 +221,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_102(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv102_anndelta));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv102_licenses));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sv102_userpath));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -238,6 +245,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_102(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv102_anndelta));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv102_licenses));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sv102_userpath));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -299,6 +307,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_402(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv402_netioalert));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv402_maxauditsz));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sv402_srvheuristics));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -340,6 +349,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_402(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv402_netioalert));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv402_maxauditsz));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sv402_srvheuristics));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -422,6 +432,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_403(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv403_auditedevents));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv403_autoprofile));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sv403_autopath));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -466,6 +477,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_403(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv403_auditedevents));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv403_autoprofile));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sv403_autopath));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -535,6 +547,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_502(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv502_timesource));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv502_acceptdownlevelapis));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv502_lmannounce));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -563,6 +576,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_502(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv502_timesource));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv502_acceptdownlevelapis));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv502_lmannounce));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -640,6 +654,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_503(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv503_enablesharednetdrives));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv503_minfreeconnections));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv503_maxfreeconnections));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -692,6 +707,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_503(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv503_enablesharednetdrives));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv503_minfreeconnections));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv503_maxfreeconnections));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -807,6 +823,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_599(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv599_linkinfovalidtime));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv599_scavqosinfoupdatetime));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv599_maxworkitemidletime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -873,6 +890,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_599(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv599_linkinfovalidtime));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv599_scavqosinfoupdatetime));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv599_maxworkitemidletime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -988,6 +1006,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_598(struct ndr_push *ndr, int nd
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv598_disabledos));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv598_lowdiskspaceminimum));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv598_disablestrictnamechecking));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->sv598_serverguid));
@@ -1041,6 +1060,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_598(struct ndr_pull *ndr, int nd
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv598_disabledos));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv598_lowdiskspaceminimum));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv598_disablestrictnamechecking));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->sv598_serverguid));
@@ -1102,6 +1122,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1005(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sv1005_comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1113,6 +1134,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1005(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sv1005_comment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1132,6 +1154,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1107(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1107_users));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1143,6 +1166,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1107(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1107_users));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1162,6 +1186,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1010(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->sv1010_disc));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1173,6 +1198,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1010(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->sv1010_disc));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1192,6 +1218,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1016(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1016_hidden));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1203,6 +1230,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1016(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1016_hidden));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1222,6 +1250,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1017(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1017_announce));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1233,6 +1262,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1017(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1017_announce));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1252,6 +1282,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1018(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1018_anndelta));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1263,6 +1294,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1018(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1018_anndelta));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1282,6 +1314,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1501(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1501_sessopens));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1293,6 +1326,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1501(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1501_sessopens));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1312,6 +1346,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1502(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1502_sessvcs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1323,6 +1358,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1502(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1502_sessvcs));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1342,6 +1378,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1503(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1503_opensearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1353,6 +1390,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1503(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1503_opensearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1372,6 +1410,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1506(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1506_maxworkitems));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1383,6 +1422,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1506(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1506_maxworkitems));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1402,6 +1442,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1509(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1509_maxrawbuflen));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1413,6 +1454,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1509(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1509_maxrawbuflen));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1432,6 +1474,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1510(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1510_sessusers));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1443,6 +1486,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1510(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1510_sessusers));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1462,6 +1506,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1511(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1511_sessconns));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1473,6 +1518,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1511(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1511_sessconns));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1492,6 +1538,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1512(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1512_maxnonpagedmemoryusage));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1503,6 +1550,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1512(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1512_maxnonpagedmemoryusage));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1522,6 +1570,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1513(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1513_maxpagedmemoryusage));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1533,6 +1582,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1513(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1513_maxpagedmemoryusage));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1552,6 +1602,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1514(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1514_enablesoftcompat));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1563,6 +1614,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1514(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1514_enablesoftcompat));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1582,6 +1634,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1515(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1515_enableforcedlogoff));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1593,6 +1646,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1515(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1515_enableforcedlogoff));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1612,6 +1666,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1516(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1516_timesource));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1623,6 +1678,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1516(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1516_timesource));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1642,6 +1698,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1518(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1518_lmannounce));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1653,6 +1710,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1518(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1518_lmannounce));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1672,6 +1730,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1520(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1520_maxcopyreadlen));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1683,6 +1742,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1520(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1520_maxcopyreadlen));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1702,6 +1762,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1521(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1521_maxcopywritelen));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1713,6 +1774,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1521(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1521_maxcopywritelen));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1732,6 +1794,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1522(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1522_minkeepsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1743,6 +1806,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1522(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1522_minkeepsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1762,6 +1826,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1523(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1523_maxkeepsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1773,6 +1838,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1523(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1523_maxkeepsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1792,6 +1858,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1524(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1524_minkeepcomplsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1803,6 +1870,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1524(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1524_minkeepcomplsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1822,6 +1890,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1525(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1525_maxkeepcomplsearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1833,6 +1902,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1525(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1525_maxkeepcomplsearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1852,6 +1922,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1528(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1528_scavtimeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1863,6 +1934,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1528(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1528_scavtimeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1882,6 +1954,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1529(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1529_minrcvqueue));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1893,6 +1966,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1529(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1529_minrcvqueue));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1912,6 +1986,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1530(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1530_minfreeworkitems));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1923,6 +1998,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1530(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1530_minfreeworkitems));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1942,6 +2018,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1533(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1533_maxmpxct));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1953,6 +2030,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1533(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1533_maxmpxct));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1972,6 +2050,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1534(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1534_oplockbreakwait));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1983,6 +2062,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1534(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1534_oplockbreakwait));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2002,6 +2082,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1535(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1535_oplockbreakresponsewait));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2013,6 +2094,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1535(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1535_oplockbreakresponsewait));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2032,6 +2114,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1536(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1536_enableoplocks));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2043,6 +2126,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1536(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1536_enableoplocks));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2062,6 +2146,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1537(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1537_enableoplockforceclose));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2073,6 +2158,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1537(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1537_enableoplockforceclose));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2092,6 +2178,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1538(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1538_enablefcbopens));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2103,6 +2190,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1538(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1538_enablefcbopens));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2122,6 +2210,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1539(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1539_enableraw));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2133,6 +2222,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1539(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1539_enableraw));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2152,6 +2242,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1540(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1540_enablesharednetdrives));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2163,6 +2254,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1540(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1540_enablesharednetdrives));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2182,6 +2274,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1541(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1541_minfreeconnections));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2193,6 +2286,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1541(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1541_minfreeconnections));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2212,6 +2306,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1542(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1542_maxfreeconnections));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2223,6 +2318,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1542(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1542_maxfreeconnections));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2242,6 +2338,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1543(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1543_initsesstable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2253,6 +2350,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1543(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1543_initsesstable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2272,6 +2370,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1544(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1544_initconntable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2283,6 +2382,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1544(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1544_initconntable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2302,6 +2402,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1545(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1545_initfiletable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2313,6 +2414,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1545(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1545_initfiletable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2332,6 +2434,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1546(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1546_initsearchtable));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2343,6 +2446,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1546(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1546_initsearchtable));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2362,6 +2466,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1547(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1547_alertschedule));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2373,6 +2478,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1547(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1547_alertschedule));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2392,6 +2498,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1548(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1548_errorthreshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2403,6 +2510,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1548(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1548_errorthreshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2422,6 +2530,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1549(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1549_networkerrorthreshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2433,6 +2542,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1549(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1549_networkerrorthreshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2452,6 +2562,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1550(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1550_diskspacethreshold));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2463,6 +2574,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1550(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1550_diskspacethreshold));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2482,6 +2594,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1552(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1552_maxlinkdelay));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2493,6 +2606,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1552(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1552_maxlinkdelay));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2512,6 +2626,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1553(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1553_minlinkthroughput));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2523,6 +2638,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1553(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1553_minlinkthroughput));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2542,6 +2658,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1554(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1554_linkinfovalidtime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2553,6 +2670,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1554(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1554_linkinfovalidtime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2572,6 +2690,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1555(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1555_scavqosinfoupdatetime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2583,6 +2702,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1555(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1555_scavqosinfoupdatetime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2602,6 +2722,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1556(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1556_maxworkitemidletime));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2613,6 +2734,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1556(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1556_maxworkitemidletime));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2632,6 +2754,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1557(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1557_maxrawworkitems));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2643,6 +2766,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1557(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1557_maxrawworkitems));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2662,6 +2786,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1560(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1560_producttype));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2673,6 +2798,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1560(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1560_producttype));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2692,6 +2818,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1561(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1561_serversize));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2703,6 +2830,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1561(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1561_serversize));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2722,6 +2850,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1562(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1562_connectionlessautodisc));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2733,6 +2862,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1562(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1562_connectionlessautodisc));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2752,6 +2882,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1563(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1563_sharingviolationretries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2763,6 +2894,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1563(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1563_sharingviolationretries));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2782,6 +2914,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1564(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1564_sharingviolationdelay));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2793,6 +2926,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1564(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1564_sharingviolationdelay));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2812,6 +2946,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1565(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1565_maxglobalopensearch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2823,6 +2958,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1565(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1565_maxglobalopensearch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2842,6 +2978,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1566(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1566_removeduplicatesearches));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2853,6 +2990,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1566(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1566_removeduplicatesearches));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2872,6 +3010,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1567(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1567_lockviolationretries));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2883,6 +3022,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1567(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1567_lockviolationretries));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2902,6 +3042,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1568(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1568_lockviolationoffset));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2913,6 +3054,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1568(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1568_lockviolationoffset));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2932,6 +3074,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1569(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1569_lockviolationdelay));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2943,6 +3086,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1569(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1569_lockviolationdelay));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2962,6 +3106,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1570(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1570_mdlreadswitchover));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2973,6 +3118,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1570(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1570_mdlreadswitchover));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2992,6 +3138,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1571(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1571_cachedopenlimit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3003,6 +3150,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1571(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1571_cachedopenlimit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3022,6 +3170,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1572(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1572_criticalthreads));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3033,6 +3182,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1572(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1572_criticalthreads));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3052,6 +3202,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1573(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1573_restrictnullsessaccess));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3063,6 +3214,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1573(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1573_restrictnullsessaccess));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3082,6 +3234,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1574(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1574_enablewfw311directipx));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3093,6 +3246,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1574(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1574_enablewfw311directipx));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3112,6 +3266,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1575(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1575_otherqueueaffinity));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3123,6 +3278,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1575(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1575_otherqueueaffinity));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3142,6 +3298,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1576(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1576_queuesamplesecs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3153,6 +3310,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1576(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1576_queuesamplesecs));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3172,6 +3330,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1577(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1577_balancecount));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3183,6 +3342,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1577(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1577_balancecount));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3202,6 +3362,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1578(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1578_preferredaffinity));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3213,6 +3374,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1578(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1578_preferredaffinity));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3232,6 +3394,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1579(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1579_maxfreerfcbs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3243,6 +3406,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1579(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1579_maxfreerfcbs));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3262,6 +3426,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1580(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1580_maxfreemfcbs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3273,6 +3438,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1580(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1580_maxfreemfcbs));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3292,6 +3458,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1581(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1581_maxfreemlcbs));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3303,6 +3470,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1581(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1581_maxfreemlcbs));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3322,6 +3490,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1582(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1582_maxfreepagedpoolchunks));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3333,6 +3502,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1582(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1582_maxfreepagedpoolchunks));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3352,6 +3522,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1583(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1583_minpagedpoolchunksize));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3363,6 +3534,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1583(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1583_minpagedpoolchunksize));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3382,6 +3554,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1584(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1584_maxpagedpoolchunksize));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3393,6 +3566,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1584(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1584_maxpagedpoolchunksize));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3412,6 +3586,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1585(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1585_sendsfrompreferredprocessor));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3423,6 +3598,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1585(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1585_sendsfrompreferredprocessor));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3442,6 +3618,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1586(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1586_maxthreadsperqueue));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3453,6 +3630,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1586(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1586_maxthreadsperqueue));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3472,6 +3650,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1587(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1587_cacheddirectorylimit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3483,6 +3662,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1587(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1587_cacheddirectorylimit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3502,6 +3682,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1588(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1588_maxcopylength));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3513,6 +3694,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1588(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1588_maxcopylength));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3532,6 +3714,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1590(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1590_enablecompression));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3543,6 +3726,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1590(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1590_enablecompression));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3562,6 +3746,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1591(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1591_autosharewks));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3573,6 +3758,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1591(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1591_autosharewks));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3592,6 +3778,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1592(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1592_autosharewks));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3603,6 +3790,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1592(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1592_autosharewks));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3622,6 +3810,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1593(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1593_enablesecuritysignature));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3633,6 +3822,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1593(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1593_enablesecuritysignature));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3652,6 +3842,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1594(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1594_requiresecuritysignature));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3663,6 +3854,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1594(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1594_requiresecuritysignature));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3682,6 +3874,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1595(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1595_minclientbuffersize));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3693,6 +3886,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1595(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1595_minclientbuffersize));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3712,6 +3906,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1596(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1596_ConnectionNoSessionsTimeout));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3723,6 +3918,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1596(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1596_ConnectionNoSessionsTimeout));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3742,6 +3938,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1597(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1597_IdleThreadTimeOut));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3753,6 +3950,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1597(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1597_IdleThreadTimeOut));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3772,6 +3970,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1598(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1598_enableW9xsecuritysignature));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3783,6 +3982,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1598(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1598_enableW9xsecuritysignature));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3802,6 +4002,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1599(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1598_enforcekerberosreauthentication));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3813,6 +4014,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1599(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1598_enforcekerberosreauthentication));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3832,6 +4034,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1600(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv1598_disabledos));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3843,6 +4046,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1600(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv1598_disabledos));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3862,6 +4066,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1601(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sv1598_lowdiskspaceminimum));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3873,6 +4078,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1601(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sv1598_lowdiskspaceminimum));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3892,6 +4098,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_SERVER_INFO_1602(struct ndr_push *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->sv_1598_disablestrictnamechecking));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3903,6 +4110,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_SERVER_INFO_1602(struct ndr_pull *ndr, int n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sv_1598_disablestrictnamechecking));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3930,6 +4138,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_DOMAIN_CONTROLLER_INFO(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dc_site_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->client_site_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
@@ -3950,6 +4159,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_DOMAIN_CONTROLLER_INFO(struct ndr_pull *ndr,
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dc_site_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->client_site_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
@@ -3978,6 +4188,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_0(struct ndr_push *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri0_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -3989,6 +4200,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_0(struct ndr_pull *ndr, int ndr_fl
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri0_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4015,6 +4227,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1_comment));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1_flags));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1_script_path));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4033,6 +4246,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1_comment));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1_flags));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1_script_path));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4057,7 +4271,7 @@ _PUBLIC_ void ndr_print_USER_INFO_1(struct ndr_print *ndr, const char *name, con
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_2(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri2_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri2_password));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri2_password_age));
@@ -4082,6 +4296,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_2(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri2_logon_server));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri2_country_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri2_code_page));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri2_logon_hours) {
@@ -4096,7 +4311,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_2(struct ndr_pull *ndr, int ndr_fl
        uint32_t _ptr_usri2_logon_hours;
        TALLOC_CTX *_mem_save_usri2_logon_hours_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri2_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri2_password));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri2_password_age));
@@ -4126,6 +4341,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_2(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri2_logon_server));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri2_country_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri2_code_page));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri2_logon_hours) {
@@ -4177,7 +4393,7 @@ _PUBLIC_ void ndr_print_USER_INFO_2(struct ndr_print *ndr, const char *name, con
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_3(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_3 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri3_name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri3_password_age));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri3_priv));
@@ -4206,6 +4422,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_3(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri3_profile));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri3_home_dir_drive));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri3_password_expired));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri3_logon_hours) {
@@ -4220,7 +4437,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_3(struct ndr_pull *ndr, int ndr_fl
        uint32_t _ptr_usri3_logon_hours;
        TALLOC_CTX *_mem_save_usri3_logon_hours_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri3_name));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri3_password_age));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri3_priv));
@@ -4254,6 +4471,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_3(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri3_profile));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri3_home_dir_drive));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri3_password_expired));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri3_logon_hours) {
@@ -4309,7 +4527,7 @@ _PUBLIC_ void ndr_print_USER_INFO_3(struct ndr_print *ndr, const char *name, con
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_4(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_4 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri4_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri4_password));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri4_password_age));
@@ -4339,6 +4557,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_4(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri4_profile));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri4_home_dir_drive));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri4_password_expired));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri4_logon_hours) {
@@ -4358,7 +4577,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_4(struct ndr_pull *ndr, int ndr_fl
        uint32_t _ptr_usri4_user_sid;
        TALLOC_CTX *_mem_save_usri4_user_sid_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri4_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri4_password));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri4_password_age));
@@ -4398,6 +4617,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_4(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri4_profile));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri4_home_dir_drive));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri4_password_expired));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri4_logon_hours) {
@@ -4470,6 +4690,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_10(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri10_comment));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri10_usr_comment));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri10_full_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4484,6 +4705,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_10(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri10_comment));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri10_usr_comment));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri10_full_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4504,7 +4726,7 @@ _PUBLIC_ void ndr_print_USER_INFO_10(struct ndr_print *ndr, const char *name, co
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_11(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_11 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri11_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri11_comment));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri11_usr_comment));
@@ -4525,6 +4747,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_11(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri11_units_per_week));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->usri11_logon_hours));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri11_code_page));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri11_logon_hours) {
@@ -4539,7 +4762,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_11(struct ndr_pull *ndr, int ndr_f
        uint32_t _ptr_usri11_logon_hours;
        TALLOC_CTX *_mem_save_usri11_logon_hours_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri11_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri11_comment));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri11_usr_comment));
@@ -4565,6 +4788,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_11(struct ndr_pull *ndr, int ndr_f
                        r->usri11_logon_hours = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri11_code_page));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri11_logon_hours) {
@@ -4618,6 +4842,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_20(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri20_comment));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri20_flags));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri20_user_id));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4633,6 +4858,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_20(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri20_comment));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri20_flags));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri20_user_id));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4656,6 +4882,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_21(struct ndr_push *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 1));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->usri21_password, ENCRYPTED_PWLEN));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4668,6 +4895,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_21(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_align(ndr, 1));
                NDR_PULL_ALLOC_N(ndr, r->usri21_password, ENCRYPTED_PWLEN);
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->usri21_password, ENCRYPTED_PWLEN));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4685,7 +4913,7 @@ _PUBLIC_ void ndr_print_USER_INFO_21(struct ndr_print *ndr, const char *name, co
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_22(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_22 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri22_name));
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->usri22_password, ENCRYPTED_PWLEN));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri22_password_age));
@@ -4710,6 +4938,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_22(struct ndr_push *ndr, int ndr_f
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri22_logon_server));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri22_country_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri22_code_page));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri22_logon_hours) {
@@ -4724,7 +4953,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_22(struct ndr_pull *ndr, int ndr_f
        uint32_t _ptr_usri22_logon_hours;
        TALLOC_CTX *_mem_save_usri22_logon_hours_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri22_name));
                NDR_PULL_ALLOC_N(ndr, r->usri22_password, ENCRYPTED_PWLEN);
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->usri22_password, ENCRYPTED_PWLEN));
@@ -4755,6 +4984,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_22(struct ndr_pull *ndr, int ndr_f
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri22_logon_server));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri22_country_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri22_code_page));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri22_logon_hours) {
@@ -4806,12 +5036,13 @@ _PUBLIC_ void ndr_print_USER_INFO_22(struct ndr_print *ndr, const char *name, co
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_23(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_23 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri23_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri23_full_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri23_comment));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri23_flags));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->usri23_user_sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri23_user_sid) {
@@ -4826,7 +5057,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_23(struct ndr_pull *ndr, int ndr_f
        uint32_t _ptr_usri23_user_sid;
        TALLOC_CTX *_mem_save_usri23_user_sid_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri23_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri23_full_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri23_comment));
@@ -4837,6 +5068,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_23(struct ndr_pull *ndr, int ndr_f
                } else {
                        r->usri23_user_sid = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri23_user_sid) {
@@ -4871,6 +5103,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1003(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1003_password));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4882,6 +5115,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1003(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1003_password));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4901,6 +5135,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1005(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1005_priv));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4912,6 +5147,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1005(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1005_priv));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4931,6 +5167,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1006(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1006_home_dir));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4942,6 +5179,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1006(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1006_home_dir));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4961,6 +5199,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1007(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1007_comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4972,6 +5211,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1007(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1007_comment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -4991,6 +5231,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1008(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1008_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5002,6 +5243,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1008(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1008_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5021,6 +5263,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1009(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1009_script_path));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5032,6 +5275,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1009(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1009_script_path));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5051,6 +5295,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1010(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1010_auth_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5062,6 +5307,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1010(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1010_auth_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5081,6 +5327,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1011(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1011_full_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5092,6 +5339,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1011(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1011_full_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5111,6 +5359,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1012(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1012_usr_comment));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5122,6 +5371,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1012(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1012_usr_comment));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5141,6 +5391,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1013(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1013_parms));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5152,6 +5403,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1013(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1013_parms));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5171,6 +5423,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1014(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1014_workstations));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5182,6 +5435,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1014(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1014_workstations));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5201,6 +5455,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1017(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1017_acct_expires));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5212,6 +5467,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1017(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1017_acct_expires));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5231,6 +5487,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1018(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1018_max_storage));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5242,6 +5499,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1018(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1018_max_storage));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5259,9 +5517,10 @@ _PUBLIC_ void ndr_print_USER_INFO_1018(struct ndr_print *ndr, const char *name,
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1020(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_1020 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1020_units_per_week));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->usri1020_logon_hours));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri1020_logon_hours) {
@@ -5276,7 +5535,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1020(struct ndr_pull *ndr, int ndr
        uint32_t _ptr_usri1020_logon_hours;
        TALLOC_CTX *_mem_save_usri1020_logon_hours_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1020_units_per_week));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_usri1020_logon_hours));
                if (_ptr_usri1020_logon_hours) {
@@ -5284,6 +5543,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1020(struct ndr_pull *ndr, int ndr
                } else {
                        r->usri1020_logon_hours = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usri1020_logon_hours) {
@@ -5315,6 +5575,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1023(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1023_logon_server));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5326,6 +5587,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1023(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1023_logon_server));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5345,6 +5607,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1024(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1024_country_code));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5356,6 +5619,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1024(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1024_country_code));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5375,6 +5639,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1025(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1025_code_page));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5386,6 +5651,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1025(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1025_code_page));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5405,6 +5671,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1051(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1051_primary_group_id));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5416,6 +5683,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1051(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1051_primary_group_id));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5435,6 +5703,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1052(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1052_profile));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5446,6 +5715,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1052(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1052_profile));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5465,6 +5735,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_1053(struct ndr_push *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1053_home_dir_drive));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5476,6 +5747,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_1053(struct ndr_pull *ndr, int ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1053_home_dir_drive));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5493,7 +5765,7 @@ _PUBLIC_ void ndr_print_USER_INFO_1053(struct ndr_print *ndr, const char *name,
 _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_X(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_X *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usriX_name));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usriX_password));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_password_age));
@@ -5523,6 +5795,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_USER_INFO_X(struct ndr_push *ndr, int ndr_fl
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_user_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_primary_group_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_password_expired));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usriX_logon_hours) {
@@ -5537,7 +5810,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_X(struct ndr_pull *ndr, int ndr_fl
        uint32_t _ptr_usriX_logon_hours;
        TALLOC_CTX *_mem_save_usriX_logon_hours_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usriX_name));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usriX_password));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_password_age));
@@ -5572,6 +5845,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_USER_INFO_X(struct ndr_pull *ndr, int ndr_fl
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_user_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_primary_group_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_password_expired));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->usriX_logon_hours) {
@@ -5630,6 +5904,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_GROUP_USERS_INFO_0(struct ndr_push *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->grui0_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5641,6 +5916,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_GROUP_USERS_INFO_0(struct ndr_pull *ndr, int
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->grui0_name));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5661,6 +5937,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_GROUP_USERS_INFO_1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->grui1_name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->grui1_attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5673,6 +5950,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_GROUP_USERS_INFO_1(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->grui1_name));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->grui1_attributes));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5698,6 +5976,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NET_DISPLAY_USER(struct ndr_push *ndr, int n
                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usri1_full_name));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1_user_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri1_next_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5714,6 +5993,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NET_DISPLAY_USER(struct ndr_pull *ndr, int n
                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usri1_full_name));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1_user_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri1_next_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5742,6 +6022,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NET_DISPLAY_MACHINE(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri2_flags));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri2_user_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usri2_next_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5757,6 +6038,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NET_DISPLAY_MACHINE(struct ndr_pull *ndr, in
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri2_flags));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri2_user_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usri2_next_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5784,6 +6066,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_NET_DISPLAY_GROUP(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->grpi3_group_id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->grpi3_attributes));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->grpi3_next_index));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5799,6 +6082,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_NET_DISPLAY_GROUP(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->grpi3_group_id));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->grpi3_attributes));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->grpi3_next_index));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7654,3 +7938,73 @@ _PUBLIC_ void ndr_print_NetShutdownAbort(struct ndr_print *ndr, const char *name
        ndr->depth--;
 }
 
+_PUBLIC_ void ndr_print_I_NetLogonControl(struct ndr_print *ndr, const char *name, int flags, const struct I_NetLogonControl *r)
+{
+       ndr_print_struct(ndr, name, "I_NetLogonControl");
+       ndr->depth++;
+       if (flags & NDR_SET_VALUES) {
+               ndr->flags |= LIBNDR_PRINT_SET_VALUES;
+       }
+       if (flags & NDR_IN) {
+               ndr_print_struct(ndr, "in", "I_NetLogonControl");
+               ndr->depth++;
+               ndr_print_string(ndr, "server_name", r->in.server_name);
+               ndr_print_uint32(ndr, "function_code", r->in.function_code);
+               ndr_print_uint32(ndr, "query_level", r->in.query_level);
+               ndr->depth--;
+       }
+       if (flags & NDR_OUT) {
+               ndr_print_struct(ndr, "out", "I_NetLogonControl");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "buffer", r->out.buffer);
+               ndr->depth++;
+               ndr_print_ptr(ndr, "buffer", *r->out.buffer);
+               ndr->depth++;
+               if (*r->out.buffer) {
+                       ndr_print_uint8(ndr, "buffer", **r->out.buffer);
+               }
+               ndr->depth--;
+               ndr->depth--;
+               ndr_print_NET_API_STATUS(ndr, "result", r->out.result);
+               ndr->depth--;
+       }
+       ndr->depth--;
+}
+
+_PUBLIC_ void ndr_print_I_NetLogonControl2(struct ndr_print *ndr, const char *name, int flags, const struct I_NetLogonControl2 *r)
+{
+       ndr_print_struct(ndr, name, "I_NetLogonControl2");
+       ndr->depth++;
+       if (flags & NDR_SET_VALUES) {
+               ndr->flags |= LIBNDR_PRINT_SET_VALUES;
+       }
+       if (flags & NDR_IN) {
+               ndr_print_struct(ndr, "in", "I_NetLogonControl2");
+               ndr->depth++;
+               ndr_print_string(ndr, "server_name", r->in.server_name);
+               ndr_print_uint32(ndr, "function_code", r->in.function_code);
+               ndr_print_uint32(ndr, "query_level", r->in.query_level);
+               ndr_print_ptr(ndr, "data", r->in.data);
+               ndr->depth++;
+               ndr_print_uint8(ndr, "data", *r->in.data);
+               ndr->depth--;
+               ndr->depth--;
+       }
+       if (flags & NDR_OUT) {
+               ndr_print_struct(ndr, "out", "I_NetLogonControl2");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "buffer", r->out.buffer);
+               ndr->depth++;
+               ndr_print_ptr(ndr, "buffer", *r->out.buffer);
+               ndr->depth++;
+               if (*r->out.buffer) {
+                       ndr_print_uint8(ndr, "buffer", **r->out.buffer);
+               }
+               ndr->depth--;
+               ndr->depth--;
+               ndr_print_NET_API_STATUS(ndr, "result", r->out.result);
+               ndr->depth--;
+       }
+       ndr->depth--;
+}
+

diff --git a/source3/librpc/gen_ndr/ndr_libnetapi.h b/source3/librpc/gen_ndr/ndr_libnetapi.h
index f7143023820877941f220f6e92fedd6825460c92..e7825f2edfa025ef0361c97a857036d267af3620 100644 (file)
--- a/source3/librpc/gen_ndr/ndr_libnetapi.h
+++ b/source3/librpc/gen_ndr/ndr_libnetapi.h
@@ -108,7 +108,11 @@
 
 #define NDR_NETSHUTDOWNABORT (0x32)
 
-#define NDR_LIBNETAPI_CALL_COUNT (51)
+#define NDR_I_NETLOGONCONTROL (0x33)
+
+#define NDR_I_NETLOGONCONTROL2 (0x34)
+
+#define NDR_LIBNETAPI_CALL_COUNT (53)
 enum ndr_err_code ndr_push_NET_API_STATUS(struct ndr_push *ndr, int ndr_flags, enum NET_API_STATUS r);
 enum ndr_err_code ndr_pull_NET_API_STATUS(struct ndr_pull *ndr, int ndr_flags, enum NET_API_STATUS *r);
 void ndr_print_NET_API_STATUS(struct ndr_print *ndr, const char *name, enum NET_API_STATUS r);
@@ -697,4 +701,10 @@ void ndr_print_NetShutdownInit(struct ndr_print *ndr, const char *name, int flag
 enum ndr_err_code ndr_push_NetShutdownAbort(struct ndr_push *ndr, int flags, const struct NetShutdownAbort *r);
 enum ndr_err_code ndr_pull_NetShutdownAbort(struct ndr_pull *ndr, int flags, struct NetShutdownAbort *r);
 void ndr_print_NetShutdownAbort(struct ndr_print *ndr, const char *name, int flags, const struct NetShutdownAbort *r);
+enum ndr_err_code ndr_push_I_NetLogonControl(struct ndr_push *ndr, int flags, const struct I_NetLogonControl *r);
+enum ndr_err_code ndr_pull_I_NetLogonControl(struct ndr_pull *ndr, int flags, struct I_NetLogonControl *r);
+void ndr_print_I_NetLogonControl(struct ndr_print *ndr, const char *name, int flags, const struct I_NetLogonControl *r);
+enum ndr_err_code ndr_push_I_NetLogonControl2(struct ndr_push *ndr, int flags, const struct I_NetLogonControl2 *r);
+enum ndr_err_code ndr_pull_I_NetLogonControl2(struct ndr_pull *ndr, int flags, struct I_NetLogonControl2 *r);
+void ndr_print_I_NetLogonControl2(struct ndr_print *ndr, const char *name, int flags, const struct I_NetLogonControl2 *r);
 #endif /* _HEADER_NDR_libnetapi */

diff --git a/source3/librpc/gen_ndr/ndr_messaging.c b/source3/librpc/gen_ndr/ndr_messaging.c
index e1e95eef4eceaef479aced6ec5ff83414e4db6da..3e2aa1f3b0ff191f06eff3b99703ef8cb69791b8 100644 (file)
--- a/source3/librpc/gen_ndr/ndr_messaging.c
+++ b/source3/librpc/gen_ndr/ndr_messaging.c
@@ -5,14 +5,14 @@
 
 _PUBLIC_ enum ndr_err_code ndr_push_messaging_type(struct ndr_push *ndr, int ndr_flags, enum messaging_type r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 _PUBLIC_ enum ndr_err_code ndr_pull_messaging_type(struct ndr_pull *ndr, int ndr_flags, enum messaging_type *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -87,6 +87,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_messaging_rec(struct ndr_push *ndr, int ndr_
                NDR_CHECK(ndr_push_server_id(ndr, NDR_SCALARS, &r->dest));
                NDR_CHECK(ndr_push_server_id(ndr, NDR_SCALARS, &r->src));
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->buf));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_server_id(ndr, NDR_BUFFERS, &r->dest));
@@ -104,6 +105,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_messaging_rec(struct ndr_pull *ndr, int ndr_
                NDR_CHECK(ndr_pull_server_id(ndr, NDR_SCALARS, &r->dest));
                NDR_CHECK(ndr_pull_server_id(ndr, NDR_SCALARS, &r->src));
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->buf));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_server_id(ndr, NDR_BUFFERS, &r->dest));
@@ -133,6 +135,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_messaging_array(struct ndr_push *ndr, int nd
                for (cntr_messages_0 = 0; cntr_messages_0 < r->num_messages; cntr_messages_0++) {
                        NDR_CHECK(ndr_push_messaging_rec(ndr, NDR_SCALARS, &r->messages[cntr_messages_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_messages_0 = 0; cntr_messages_0 < r->num_messages; cntr_messages_0++) {
@@ -156,6 +159,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_messaging_array(struct ndr_pull *ndr, int nd
                        NDR_CHECK(ndr_pull_messaging_rec(ndr, NDR_SCALARS, &r->messages[cntr_messages_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_messages_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_messages_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -194,9 +198,9 @@ _PUBLIC_ enum ndr_err_code ndr_push_dbwrap_tdb2_changes(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "TDB2", 4, sizeof(uint8_t), CH_DOS));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->old_seqnum));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->new_seqnum));
@@ -205,6 +209,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_dbwrap_tdb2_changes(struct ndr_push *ndr, in
                for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->keys[cntr_keys_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -237,6 +242,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_dbwrap_tdb2_changes(struct ndr_pull *ndr, in
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }

diff --git a/source3/librpc/gen_ndr/ndr_notify.c b/source3/librpc/gen_ndr/ndr_notify.c
index 844c278cd238743c653ed670b785b5198da09b18..36f66d1ac4553c8d9fc27f2082c8d7f3e7602da5 100644 (file)
--- a/source3/librpc/gen_ndr/ndr_notify.c
+++ b/source3/librpc/gen_ndr/ndr_notify.c
@@ -20,6 +20,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_notify_entry(struct ndr_push *ndr, int ndr_f
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->path_len));
                NDR_CHECK(ndr_push_pointer(ndr, NDR_SCALARS, r->private_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_server_id(ndr, NDR_BUFFERS, &r->server));
@@ -45,6 +46,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_notify_entry(struct ndr_pull *ndr, int ndr_f
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->path_len));
                NDR_CHECK(ndr_pull_pointer(ndr, NDR_SCALARS, &r->private_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_server_id(ndr, NDR_BUFFERS, &r->server));
@@ -77,6 +79,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_notify_entry_array(struct ndr_push *ndr, int
                for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
                        NDR_CHECK(ndr_push_notify_entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
@@ -100,6 +103,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_notify_entry_array(struct ndr_pull *ndr, int
                        NDR_CHECK(ndr_pull_notify_entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -142,6 +146,7 @@ static enum ndr_err_code ndr_push_notify_depth(struct ndr_push *ndr, int ndr_fla
                for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
                        NDR_CHECK(ndr_push_notify_entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
@@ -167,6 +172,7 @@ static enum ndr_err_code ndr_pull_notify_depth(struct ndr_pull *ndr, int ndr_fla
                        NDR_CHECK(ndr_pull_notify_entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -209,6 +215,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_notify_array(struct ndr_push *ndr, int ndr_f
                for (cntr_depth_0 = 0; cntr_depth_0 < r->num_depths; cntr_depth_0++) {
                        NDR_CHECK(ndr_push_notify_depth(ndr, NDR_SCALARS, &r->depth[cntr_depth_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_depth_0 = 0; cntr_depth_0 < r->num_depths; cntr_depth_0++) {
@@ -232,6 +239,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_notify_array(struct ndr_pull *ndr, int ndr_f
                        NDR_CHECK(ndr_pull_notify_depth(ndr, NDR_SCALARS, &r->depth[cntr_depth_0]));
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_depth_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_depth_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -275,6 +283,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_notify_event(struct ndr_push *ndr, int ndr_f
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_pointer(ndr, NDR_SCALARS, r->private_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -293,6 +302,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_notify_event(struct ndr_pull *ndr, int ndr_f
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_pointer(ndr, NDR_SCALARS, &r->private_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }

diff --git a/source3/librpc/gen_ndr/ndr_perfcount.c b/source3/librpc/gen_ndr/ndr_perfcount.c
new file mode 100644 (file)
index 0000000..cd0ca5a
--- /dev/null
+++ b/source3/librpc/gen_ndr/ndr_perfcount.c
@@ -0,0 +1,505 @@
+/* parser auto-generated by pidl */
+
+#include "includes.h"
+#include "librpc/gen_ndr/ndr_perfcount.h"
+
+static enum ndr_err_code ndr_push_SYSTEMTIME(struct ndr_push *ndr, int ndr_flags, const struct SYSTEMTIME *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 2));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->dayofweek));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->milliseconds));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 2));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_SYSTEMTIME(struct ndr_pull *ndr, int ndr_flags, struct SYSTEMTIME *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 2));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->dayofweek));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->milliseconds));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_SYSTEMTIME(struct ndr_print *ndr, const char *name, const struct SYSTEMTIME *r)
+{
+       ndr_print_struct(ndr, name, "SYSTEMTIME");
+       ndr->depth++;
+       ndr_print_uint16(ndr, "year", r->year);
+       ndr_print_uint16(ndr, "month", r->month);
+       ndr_print_uint16(ndr, "dayofweek", r->dayofweek);
+       ndr_print_uint16(ndr, "day", r->day);
+       ndr_print_uint16(ndr, "hour", r->hour);
+       ndr_print_uint16(ndr, "minute", r->minute);
+       ndr_print_uint16(ndr, "second", r->second);
+       ndr_print_uint16(ndr, "milliseconds", r->milliseconds);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_PERF_COUNTER_DEFINITION(struct ndr_push *ndr, int ndr_flags, const struct PERF_COUNTER_DEFINITION *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ByteLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterNameTitleIndex));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterNameTitlePointer));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterHelpTitleIndex));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterHelpTitlePointer));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DefaultScale));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DetailLevel));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterType));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterSize));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CounterOffset));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_PERF_COUNTER_DEFINITION(struct ndr_pull *ndr, int ndr_flags, struct PERF_COUNTER_DEFINITION *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ByteLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterNameTitleIndex));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterNameTitlePointer));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterHelpTitleIndex));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterHelpTitlePointer));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DefaultScale));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DetailLevel));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterType));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterSize));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CounterOffset));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_PERF_COUNTER_DEFINITION(struct ndr_print *ndr, const char *name, const struct PERF_COUNTER_DEFINITION *r)
+{
+       ndr_print_struct(ndr, name, "PERF_COUNTER_DEFINITION");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "ByteLength", r->ByteLength);
+       ndr_print_uint32(ndr, "CounterNameTitleIndex", r->CounterNameTitleIndex);
+       ndr_print_uint32(ndr, "CounterNameTitlePointer", r->CounterNameTitlePointer);
+       ndr_print_uint32(ndr, "CounterHelpTitleIndex", r->CounterHelpTitleIndex);
+       ndr_print_uint32(ndr, "CounterHelpTitlePointer", r->CounterHelpTitlePointer);
+       ndr_print_uint32(ndr, "DefaultScale", r->DefaultScale);
+       ndr_print_uint32(ndr, "DetailLevel", r->DetailLevel);
+       ndr_print_uint32(ndr, "CounterType", r->CounterType);
+       ndr_print_uint32(ndr, "CounterSize", r->CounterSize);
+       ndr_print_uint32(ndr, "CounterOffset", r->CounterOffset);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_PERF_COUNTER_BLOCK(struct ndr_push *ndr, int ndr_flags, const struct PERF_COUNTER_BLOCK *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ByteLength));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->ByteLength));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_PERF_COUNTER_BLOCK(struct ndr_pull *ndr, int ndr_flags, struct PERF_COUNTER_BLOCK *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ByteLength));
+               NDR_PULL_ALLOC_N(ndr, r->data, r->ByteLength);
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, r->ByteLength));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_PERF_COUNTER_BLOCK(struct ndr_print *ndr, const char *name, const struct PERF_COUNTER_BLOCK *r)
+{
+       ndr_print_struct(ndr, name, "PERF_COUNTER_BLOCK");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "ByteLength", r->ByteLength);
+       ndr_print_array_uint8(ndr, "data", r->data, r->ByteLength);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_PERF_INSTANCE_DEFINITION(struct ndr_push *ndr, int ndr_flags, const struct PERF_INSTANCE_DEFINITION *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ByteLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ParentObjectTitleIndex));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ParentObjectTitlePointer));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->UniqueID));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NameOffset));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NameLength));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_PERF_COUNTER_BLOCK(ndr, NDR_SCALARS, &r->counter_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->data) {
+                       NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->data));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_PERF_INSTANCE_DEFINITION(struct ndr_pull *ndr, int ndr_flags, struct PERF_INSTANCE_DEFINITION *r)
+{
+       uint32_t _ptr_data;
+       TALLOC_CTX *_mem_save_data_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ByteLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ParentObjectTitleIndex));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ParentObjectTitlePointer));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UniqueID));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NameOffset));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NameLength));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
+               if (_ptr_data) {
+                       NDR_PULL_ALLOC(ndr, r->data);
+               } else {
+                       r->data = NULL;
+               }
+               NDR_CHECK(ndr_pull_PERF_COUNTER_BLOCK(ndr, NDR_SCALARS, &r->counter_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->data) {
+                       _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
+                       NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->data));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_PERF_INSTANCE_DEFINITION(struct ndr_print *ndr, const char *name, const struct PERF_INSTANCE_DEFINITION *r)
+{
+       ndr_print_struct(ndr, name, "PERF_INSTANCE_DEFINITION");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "ByteLength", r->ByteLength);
+       ndr_print_uint32(ndr, "ParentObjectTitleIndex", r->ParentObjectTitleIndex);
+       ndr_print_uint32(ndr, "ParentObjectTitlePointer", r->ParentObjectTitlePointer);
+       ndr_print_uint32(ndr, "UniqueID", r->UniqueID);
+       ndr_print_uint32(ndr, "NameOffset", r->NameOffset);
+       ndr_print_uint32(ndr, "NameLength", r->NameLength);
+       ndr_print_ptr(ndr, "data", r->data);
+       ndr->depth++;
+       if (r->data) {
+               ndr_print_uint8(ndr, "data", *r->data);
+       }
+       ndr->depth--;
+       ndr_print_PERF_COUNTER_BLOCK(ndr, "counter_data", &r->counter_data);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_PERF_OBJECT_TYPE(struct ndr_push *ndr, int ndr_flags, const struct PERF_OBJECT_TYPE *r)
+{
+       uint32_t cntr_counters_0;
+       uint32_t cntr_instances_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 8));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->TotalByteLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DefinitionLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->HeaderLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectNameTitleIndex));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectNameTitlePointer));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectHelpTitleIndex));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectHelpTitlePointer));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DetailLevel));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NumCounters));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DefaultCounter));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NumInstances));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CodePage));
+               NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfTime));
+               NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfFreq));
+               for (cntr_counters_0 = 0; cntr_counters_0 < r->NumCounters; cntr_counters_0++) {
+                       NDR_CHECK(ndr_push_PERF_COUNTER_DEFINITION(ndr, NDR_SCALARS, &r->counters[cntr_counters_0]));
+               }
+               for (cntr_instances_0 = 0; cntr_instances_0 < r->NumInstances; cntr_instances_0++) {
+                       NDR_CHECK(ndr_push_PERF_INSTANCE_DEFINITION(ndr, NDR_SCALARS, &r->instances[cntr_instances_0]));
+               }
+               NDR_CHECK(ndr_push_PERF_COUNTER_BLOCK(ndr, NDR_SCALARS, &r->counter_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               for (cntr_instances_0 = 0; cntr_instances_0 < r->NumInstances; cntr_instances_0++) {
+                       NDR_CHECK(ndr_push_PERF_INSTANCE_DEFINITION(ndr, NDR_BUFFERS, &r->instances[cntr_instances_0]));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_PERF_OBJECT_TYPE(struct ndr_pull *ndr, int ndr_flags, struct PERF_OBJECT_TYPE *r)
+{
+       uint32_t cntr_counters_0;
+       TALLOC_CTX *_mem_save_counters_0;
+       uint32_t cntr_instances_0;
+       TALLOC_CTX *_mem_save_instances_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 8));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->TotalByteLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DefinitionLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->HeaderLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ObjectNameTitleIndex));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ObjectNameTitlePointer));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ObjectHelpTitleIndex));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ObjectHelpTitlePointer));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DetailLevel));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NumCounters));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DefaultCounter));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NumInstances));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CodePage));
+               NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->PerfTime));
+               NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->PerfFreq));
+               NDR_PULL_ALLOC_N(ndr, r->counters, r->NumCounters);
+               _mem_save_counters_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->counters, 0);
+               for (cntr_counters_0 = 0; cntr_counters_0 < r->NumCounters; cntr_counters_0++) {
+                       NDR_CHECK(ndr_pull_PERF_COUNTER_DEFINITION(ndr, NDR_SCALARS, &r->counters[cntr_counters_0]));
+               }
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_counters_0, 0);
+               NDR_PULL_ALLOC_N(ndr, r->instances, r->NumInstances);
+               _mem_save_instances_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->instances, 0);
+               for (cntr_instances_0 = 0; cntr_instances_0 < r->NumInstances; cntr_instances_0++) {
+                       NDR_CHECK(ndr_pull_PERF_INSTANCE_DEFINITION(ndr, NDR_SCALARS, &r->instances[cntr_instances_0]));
+               }
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_instances_0, 0);
+               NDR_CHECK(ndr_pull_PERF_COUNTER_BLOCK(ndr, NDR_SCALARS, &r->counter_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               _mem_save_instances_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->instances, 0);
+               for (cntr_instances_0 = 0; cntr_instances_0 < r->NumInstances; cntr_instances_0++) {
+                       NDR_CHECK(ndr_pull_PERF_INSTANCE_DEFINITION(ndr, NDR_BUFFERS, &r->instances[cntr_instances_0]));
+               }
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_instances_0, 0);
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_PERF_OBJECT_TYPE(struct ndr_print *ndr, const char *name, const struct PERF_OBJECT_TYPE *r)
+{
+       uint32_t cntr_counters_0;
+       uint32_t cntr_instances_0;
+       ndr_print_struct(ndr, name, "PERF_OBJECT_TYPE");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "TotalByteLength", r->TotalByteLength);
+       ndr_print_uint32(ndr, "DefinitionLength", r->DefinitionLength);
+       ndr_print_uint32(ndr, "HeaderLength", r->HeaderLength);
+       ndr_print_uint32(ndr, "ObjectNameTitleIndex", r->ObjectNameTitleIndex);
+       ndr_print_uint32(ndr, "ObjectNameTitlePointer", r->ObjectNameTitlePointer);
+       ndr_print_uint32(ndr, "ObjectHelpTitleIndex", r->ObjectHelpTitleIndex);
+       ndr_print_uint32(ndr, "ObjectHelpTitlePointer", r->ObjectHelpTitlePointer);
+       ndr_print_uint32(ndr, "DetailLevel", r->DetailLevel);
+       ndr_print_uint32(ndr, "NumCounters", r->NumCounters);
+       ndr_print_uint32(ndr, "DefaultCounter", r->DefaultCounter);
+       ndr_print_uint32(ndr, "NumInstances", r->NumInstances);
+       ndr_print_uint32(ndr, "CodePage", r->CodePage);
+       ndr_print_hyper(ndr, "PerfTime", r->PerfTime);
+       ndr_print_hyper(ndr, "PerfFreq", r->PerfFreq);
+       ndr->print(ndr, "%s: ARRAY(%d)", "counters", (int)r->NumCounters);
+       ndr->depth++;
+       for (cntr_counters_0=0;cntr_counters_0<r->NumCounters;cntr_counters_0++) {
+               char *idx_0=NULL;
+               if (asprintf(&idx_0, "[%d]", cntr_counters_0) != -1) {
+                       ndr_print_PERF_COUNTER_DEFINITION(ndr, "counters", &r->counters[cntr_counters_0]);
+                       free(idx_0);
+               }
+       }
+       ndr->depth--;
+       ndr->print(ndr, "%s: ARRAY(%d)", "instances", (int)r->NumInstances);
+       ndr->depth++;
+       for (cntr_instances_0=0;cntr_instances_0<r->NumInstances;cntr_instances_0++) {
+               char *idx_0=NULL;
+               if (asprintf(&idx_0, "[%d]", cntr_instances_0) != -1) {
+                       ndr_print_PERF_INSTANCE_DEFINITION(ndr, "instances", &r->instances[cntr_instances_0]);
+                       free(idx_0);
+               }
+       }
+       ndr->depth--;
+       ndr_print_PERF_COUNTER_BLOCK(ndr, "counter_data", &r->counter_data);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_PERF_DATA_BLOCK(struct ndr_push *ndr, int ndr_flags, const struct PERF_DATA_BLOCK *r)
+{
+       uint32_t cntr_Signature_0;
+       uint32_t cntr_objects_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 8));
+               for (cntr_Signature_0 = 0; cntr_Signature_0 < 4; cntr_Signature_0++) {
+                       NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Signature[cntr_Signature_0]));
+               }
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->LittleEndian));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Version));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Revision));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->TotalByteLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->HeaderLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NumObjectTypes));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DefaultObject));
+               NDR_CHECK(ndr_push_SYSTEMTIME(ndr, NDR_SCALARS, &r->SystemTime));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Padding));
+               NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfTime));
+               NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfFreq));
+               NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfTime100nSec));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SystemNameLength));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SystemNameOffset));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               for (cntr_objects_0 = 0; cntr_objects_0 < r->NumObjectTypes; cntr_objects_0++) {
+                       NDR_CHECK(ndr_push_PERF_OBJECT_TYPE(ndr, NDR_SCALARS, &r->objects[cntr_objects_0]));
+               }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->data) {
+                       NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->data));
+               }
+               for (cntr_objects_0 = 0; cntr_objects_0 < r->NumObjectTypes; cntr_objects_0++) {
+                       NDR_CHECK(ndr_push_PERF_OBJECT_TYPE(ndr, NDR_BUFFERS, &r->objects[cntr_objects_0]));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_PERF_DATA_BLOCK(struct ndr_pull *ndr, int ndr_flags, struct PERF_DATA_BLOCK *r)
+{
+       uint32_t cntr_Signature_0;
+       uint32_t _ptr_data;
+       TALLOC_CTX *_mem_save_data_0;
+       uint32_t cntr_objects_0;
+       TALLOC_CTX *_mem_save_objects_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 8));
+               for (cntr_Signature_0 = 0; cntr_Signature_0 < 4; cntr_Signature_0++) {
+                       NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Signature[cntr_Signature_0]));
+               }
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->LittleEndian));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Revision));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->TotalByteLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->HeaderLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NumObjectTypes));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DefaultObject));
+               NDR_CHECK(ndr_pull_SYSTEMTIME(ndr, NDR_SCALARS, &r->SystemTime));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Padding));
+               NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->PerfTime));
+               NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->PerfFreq));
+               NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->PerfTime100nSec));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SystemNameLength));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SystemNameOffset));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
+               if (_ptr_data) {
+                       NDR_PULL_ALLOC(ndr, r->data);
+               } else {
+                       r->data = NULL;
+               }
+               NDR_PULL_ALLOC_N(ndr, r->objects, r->NumObjectTypes);
+               _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
+               for (cntr_objects_0 = 0; cntr_objects_0 < r->NumObjectTypes; cntr_objects_0++) {
+                       NDR_CHECK(ndr_pull_PERF_OBJECT_TYPE(ndr, NDR_SCALARS, &r->objects[cntr_objects_0]));
+               }
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->data) {
+                       _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
+                       NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->data));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
+               }
+               _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
+               for (cntr_objects_0 = 0; cntr_objects_0 < r->NumObjectTypes; cntr_objects_0++) {
+                       NDR_CHECK(ndr_pull_PERF_OBJECT_TYPE(ndr, NDR_BUFFERS, &r->objects[cntr_objects_0]));
+               }
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_PERF_DATA_BLOCK(struct ndr_print *ndr, const char *name, const struct PERF_DATA_BLOCK *r)
+{
+       uint32_t cntr_Signature_0;
+       uint32_t cntr_objects_0;
+       ndr_print_struct(ndr, name, "PERF_DATA_BLOCK");
+       ndr->depth++;
+       ndr->print(ndr, "%s: ARRAY(%d)", "Signature", (int)4);
+       ndr->depth++;
+       for (cntr_Signature_0=0;cntr_Signature_0<4;cntr_Signature_0++) {
+               char *idx_0=NULL;
+               if (asprintf(&idx_0, "[%d]", cntr_Signature_0) != -1) {
+                       ndr_print_uint16(ndr, "Signature", r->Signature[cntr_Signature_0]);
+                       free(idx_0);
+               }
+       }
+       ndr->depth--;
+       ndr_print_uint32(ndr, "LittleEndian", r->LittleEndian);
+       ndr_print_uint32(ndr, "Version", r->Version);
+       ndr_print_uint32(ndr, "Revision", r->Revision);
+       ndr_print_uint32(ndr, "TotalByteLength", r->TotalByteLength);
+       ndr_print_uint32(ndr, "HeaderLength", r->HeaderLength);
+       ndr_print_uint32(ndr, "NumObjectTypes", r->NumObjectTypes);
+       ndr_print_uint32(ndr, "DefaultObject", r->DefaultObject);
+       ndr_print_SYSTEMTIME(ndr, "SystemTime", &r->SystemTime);
+       ndr_print_uint32(ndr, "Padding", r->Padding);
+       ndr_print_hyper(ndr, "PerfTime", r->PerfTime);
+       ndr_print_hyper(ndr, "PerfFreq", r->PerfFreq);
+       ndr_print_hyper(ndr, "PerfTime100nSec", r->PerfTime100nSec);
+       ndr_print_uint32(ndr, "SystemNameLength", r->SystemNameLength);
+       ndr_print_uint32(ndr, "SystemNameOffset", r->SystemNameOffset);
+       ndr_print_ptr(ndr, "data", r->data);
+       ndr->depth++;
+       if (r->data) {
+               ndr_print_uint8(ndr, "data", *r->data);
+       }
+       ndr->depth--;
+       ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->NumObjectTypes);
+       ndr->depth++;
+       for (cntr_objects_0=0;cntr_objects_0<r->NumObjectTypes;cntr_objects_0++) {
+               char *idx_0=NULL;
+               if (asprintf(&idx_0, "[%d]", cntr_objects_0) != -1) {
+                       ndr_print_PERF_OBJECT_TYPE(ndr, "objects", &r->objects[cntr_objects_0]);
+                       free(idx_0);
+               }
+       }
+       ndr->depth--;
+       ndr->depth--;
+}
+

diff --git a/source3/librpc/gen_ndr/ndr_perfcount.h b/source3/librpc/gen_ndr/ndr_perfcount.h
new file mode 100644 (file)
index 0000000..8697bf0
--- /dev/null
+++ b/source3/librpc/gen_ndr/ndr_perfcount.h
@@ -0,0 +1,26 @@
+/* header auto-generated by pidl */
+
+#include "librpc/ndr/libndr.h"
+#include "librpc/gen_ndr/perfcount.h"
+
+#ifndef _HEADER_NDR_perfcount
+#define _HEADER_NDR_perfcount
+
+#define NDR_PERFCOUNT_CALL_COUNT (0)
+void ndr_print_SYSTEMTIME(struct ndr_print *ndr, const char *name, const struct SYSTEMTIME *r);
+enum ndr_err_code ndr_push_PERF_COUNTER_DEFINITION(struct ndr_push *ndr, int ndr_flags, const struct PERF_COUNTER_DEFINITION *r);
+enum ndr_err_code ndr_pull_PERF_COUNTER_DEFINITION(struct ndr_pull *ndr, int ndr_flags, struct PERF_COUNTER_DEFINITION *r);
+void ndr_print_PERF_COUNTER_DEFINITION(struct ndr_print *ndr, const char *name, const struct PERF_COUNTER_DEFINITION *r);
+enum ndr_err_code ndr_push_PERF_COUNTER_BLOCK(struct ndr_push *ndr, int ndr_flags, const struct PERF_COUNTER_BLOCK *r);
+enum ndr_err_code ndr_pull_PERF_COUNTER_BLOCK(struct ndr_pull *ndr, int ndr_flags, struct PERF_COUNTER_BLOCK *r);
+void ndr_print_PERF_COUNTER_BLOCK(struct ndr_print *ndr, const char *name, const struct PERF_COUNTER_BLOCK *r);
+enum ndr_err_code ndr_push_PERF_INSTANCE_DEFINITION(struct ndr_push *ndr, int ndr_flags, const struct PERF_INSTANCE_DEFINITION *r);
+enum ndr_err_code ndr_pull_PERF_INSTANCE_DEFINITION(struct ndr_pull *ndr, int ndr_flags, struct PERF_INSTANCE_DEFINITION *r);
+void ndr_print_PERF_INSTANCE_DEFINITION(struct ndr_print *ndr, const char *name, const struct PERF_INSTANCE_DEFINITION *r);
+enum ndr_err_code ndr_push_PERF_OBJECT_TYPE(struct ndr_push *ndr, int ndr_flags, const struct PERF_OBJECT_TYPE *r);
+enum ndr_err_code ndr_pull_PERF_OBJECT_TYPE(struct ndr_pull *ndr, int ndr_flags, struct PERF_OBJECT_TYPE *r);
+void ndr_print_PERF_OBJECT_TYPE(struct ndr_print *ndr, const char *name, const struct PERF_OBJECT_TYPE *r);
+enum ndr_err_code ndr_push_PERF_DATA_BLOCK(struct ndr_push *ndr, int ndr_flags, const struct PERF_DATA_BLOCK *r);
+enum ndr_err_code ndr_pull_PERF_DATA_BLOCK(struct ndr_pull *ndr, int ndr_flags, struct PERF_DATA_BLOCK *r);
+void ndr_print_PERF_DATA_BLOCK(struct ndr_print *ndr, const char *name, const struct PERF_DATA_BLOCK *r);
+#endif /* _HEADER_NDR_perfcount */

diff --git a/source3/librpc/gen_ndr/ndr_wbint.c b/source3/librpc/gen_ndr/ndr_wbint.c
index d5f46a43b322c3842444af9e549efd6eb0fae29a..7c6aac987bea8c2536ade3c7ec50141fe4d15289 100644 (file)
--- a/source3/librpc/gen_ndr/ndr_wbint.c
+++ b/source3/librpc/gen_ndr/ndr_wbint.c
@@ -15,30 +15,31 @@ _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfo(struct ndr_push *ndr, int ndr
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->primary_gid));
                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->acct_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->acct_name, ndr_charset_length(r->acct_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                if (r->full_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->full_name, ndr_charset_length(r->full_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                if (r->homedir) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->homedir, ndr_charset_length(r->homedir, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                if (r->shell) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->shell, ndr_charset_length(r->shell, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
        }
@@ -84,6 +85,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfo(struct ndr_pull *ndr, int ndr
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->primary_gid));
                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->acct_name) {
@@ -176,12 +178,13 @@ _PUBLIC_ enum ndr_err_code ndr_push_wbint_SidArray(struct ndr_push *ndr, int ndr
 {
        uint32_t cntr_sids_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
                for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
                        NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -206,6 +209,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_SidArray(struct ndr_pull *ndr, int ndr
                if (r->sids) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -235,12 +239,13 @@ _PUBLIC_ enum ndr_err_code ndr_push_wbint_RidArray(struct ndr_push *ndr, int ndr
 {
        uint32_t cntr_rids_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_rids));
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
                for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -265,6 +270,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_RidArray(struct ndr_pull *ndr, int ndr
                if (r->rids) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->num_rids));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -293,16 +299,17 @@ _PUBLIC_ void ndr_print_wbint_RidArray(struct ndr_print *ndr, const char *name,
 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principal(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principal *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
        }
@@ -314,7 +321,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principal(struct ndr_pull *ndr, int nd
        uint32_t _ptr_name;
        TALLOC_CTX *_mem_save_name_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
@@ -323,6 +330,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principal(struct ndr_pull *ndr, int nd
                } else {
                        r->name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->name) {
@@ -360,12 +368,13 @@ _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principals(struct ndr_push *ndr, int n
 {
        uint32_t cntr_principals_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_principals));
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_principals));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->num_principals));
                for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
                        NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
@@ -381,7 +390,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principals(struct ndr_pull *ndr, int n
        TALLOC_CTX *_mem_save_principals_0;
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_array_size(ndr, &r->principals));
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->num_principals));
                NDR_PULL_ALLOC_N(ndr, r->principals, ndr_get_array_size(ndr, &r->principals));
                _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -393,6 +402,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principals(struct ndr_pull *ndr, int n
                if (r->principals) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->principals, r->num_principals));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -428,12 +438,13 @@ _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfos(struct ndr_push *ndr, int nd
 {
        uint32_t cntr_userinfos_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_userinfos));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
                for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
                        NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
@@ -461,6 +472,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfos(struct ndr_pull *ndr, int nd
                if (r->userinfos) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->userinfos, r->num_userinfos));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -494,14 +506,14 @@ _PUBLIC_ void ndr_print_wbint_userinfos(struct ndr_print *ndr, const char *name,
 
 _PUBLIC_ enum ndr_err_code ndr_push_wbint_IdType(struct ndr_push *ndr, int ndr_flags, enum wbint_IdType r)
 {
-       NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_IdType(struct ndr_pull *ndr, int ndr_flags, enum wbint_IdType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -597,9 +609,9 @@ static enum ndr_err_code ndr_push_wbint_LookupSid(struct ndr_push *ndr, int flag
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domain));
                if (*r->out.domain) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.domain, ndr_charset_length(*r->out.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                if (r->out.name == NULL) {
@@ -607,9 +619,9 @@ static enum ndr_err_code ndr_push_wbint_LookupSid(struct ndr_push *ndr, int flag
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name));
                if (*r->out.name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.name, ndr_charset_length(*r->out.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
@@ -758,16 +770,16 @@ static enum ndr_err_code ndr_push_wbint_LookupName(struct ndr_push *ndr, int fla
                if (r->in.domain == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain, ndr_charset_length(r->in.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                if (r->in.name == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
        }
@@ -875,9 +887,9 @@ static enum ndr_err_code ndr_push_wbint_Sid2Uid(struct ndr_push *ndr, int flags,
        if (flags & NDR_IN) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
                if (r->in.dom_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                if (r->in.sid == NULL) {
@@ -985,9 +997,9 @@ static enum ndr_err_code ndr_push_wbint_Sid2Gid(struct ndr_push *ndr, int flags,
        if (flags & NDR_IN) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
                if (r->in.dom_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                if (r->in.sid == NULL) {
@@ -1095,9 +1107,9 @@ static enum ndr_err_code ndr_push_wbint_Uid2Sid(struct ndr_push *ndr, int flags,
        if (flags & NDR_IN) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
                if (r->in.dom_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.uid));
@@ -1192,9 +1204,9 @@ static enum ndr_err_code ndr_push_wbint_Gid2Sid(struct ndr_push *ndr, int flags,
        if (flags & NDR_IN) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
                if (r->in.dom_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.gid));
@@ -1906,9 +1918,9 @@ static enum ndr_err_code ndr_push_wbint_DsGetDcName(struct ndr_push *ndr, int fl
                if (r->in.domain_name == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_guid));
                if (r->in.domain_guid) {
@@ -1916,9 +1928,9 @@ static enum ndr_err_code ndr_push_wbint_DsGetDcName(struct ndr_push *ndr, int fl
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.site_name));
                if (r->in.site_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.site_name, ndr_charset_length(r->in.site_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
@@ -2178,6 +2190,47 @@ _PUBLIC_ void ndr_print_wbint_CheckMachineAccount(struct ndr_print *ndr, const c
        ndr->depth--;
 }
 
+static enum ndr_err_code ndr_push_wbint_ChangeMachineAccount(struct ndr_push *ndr, int flags, const struct wbint_ChangeMachineAccount *r)
+{
+       if (flags & NDR_IN) {
+       }
+       if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_wbint_ChangeMachineAccount(struct ndr_pull *ndr, int flags, struct wbint_ChangeMachineAccount *r)
+{
+       if (flags & NDR_IN) {
+       }
+       if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_wbint_ChangeMachineAccount(struct ndr_print *ndr, const char *name, int flags, const struct wbint_ChangeMachineAccount *r)
+{
+       ndr_print_struct(ndr, name, "wbint_ChangeMachineAccount");
+       ndr->depth++;
+       if (flags & NDR_SET_VALUES) {
+               ndr->flags |= LIBNDR_PRINT_SET_VALUES;
+       }
+       if (flags & NDR_IN) {
+               ndr_print_struct(ndr, "in", "wbint_ChangeMachineAccount");
+               ndr->depth++;
+               ndr->depth--;
+       }
+       if (flags & NDR_OUT) {
+               ndr_print_struct(ndr, "out", "wbint_ChangeMachineAccount");
+               ndr->depth++;
+               ndr_print_NTSTATUS(ndr, "result", r->out.result);
+               ndr->depth--;
+       }
+       ndr->depth--;
+}
+
 static enum ndr_err_code ndr_push_wbint_SetMapping(struct ndr_push *ndr, int flags, const struct wbint_SetMapping *r)
 {
        if (flags & NDR_IN) {
@@ -2504,6 +2557,14 @@ static const struct ndr_interface_call wbint_calls[] = {
                (ndr_print_function_t) ndr_print_wbint_CheckMachineAccount,
                false,
        },
+       {
+               "wbint_ChangeMachineAccount",
+               sizeof(struct wbint_ChangeMachineAccount),
+               (ndr_push_flags_fn_t) ndr_push_wbint_ChangeMachineAccount,
+               (ndr_pull_flags_fn_t) ndr_pull_wbint_ChangeMachineAccount,
+               (ndr_print_function_t) ndr_print_wbint_ChangeMachineAccount,
+               false,
+       },
        {
                "wbint_SetMapping",
                sizeof(struct wbint_SetMapping),
@@ -2557,7 +2618,7 @@ const struct ndr_interface_table ndr_table_wbint = {
                NDR_WBINT_VERSION
        },
        .helpstring     = NDR_WBINT_HELPSTRING,
-       .num_calls      = 22,
+       .num_calls      = 23,
        .calls          = wbint_calls,
        .endpoints      = &wbint_endpoints,
        .authservices   = &wbint_authservices

diff --git a/source3/librpc/gen_ndr/ndr_wbint.h b/source3/librpc/gen_ndr/ndr_wbint.h
index 5cefc94162c1b4a6cfd51baa68a8e2edd9f060e8..e163ff367478fef84fff6579e8f9db6ecaa064ae 100644 (file)
--- a/source3/librpc/gen_ndr/ndr_wbint.h
+++ b/source3/librpc/gen_ndr/ndr_wbint.h
@@ -49,13 +49,15 @@ extern const struct ndr_interface_table ndr_table_wbint;
 
 #define NDR_WBINT_CHECKMACHINEACCOUNT (0x12)
 
-#define NDR_WBINT_SETMAPPING (0x13)
+#define NDR_WBINT_CHANGEMACHINEACCOUNT (0x13)
 
-#define NDR_WBINT_REMOVEMAPPING (0x14)
+#define NDR_WBINT_SETMAPPING (0x14)
 
-#define NDR_WBINT_SETHWM (0x15)
+#define NDR_WBINT_REMOVEMAPPING (0x15)
 
-#define NDR_WBINT_CALL_COUNT (22)
+#define NDR_WBINT_SETHWM (0x16)
+
+#define NDR_WBINT_CALL_COUNT (23)
 enum ndr_err_code ndr_push_wbint_userinfo(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfo *r);
 enum ndr_err_code ndr_pull_wbint_userinfo(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfo *r);
 void ndr_print_wbint_userinfo(struct ndr_print *ndr, const char *name, const struct wbint_userinfo *r);
@@ -96,6 +98,7 @@ void ndr_print_wbint_QueryGroupList(struct ndr_print *ndr, const char *name, int
 void ndr_print_wbint_DsGetDcName(struct ndr_print *ndr, const char *name, int flags, const struct wbint_DsGetDcName *r);
 void ndr_print_wbint_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupRids *r);
 void ndr_print_wbint_CheckMachineAccount(struct ndr_print *ndr, const char *name, int flags, const struct wbint_CheckMachineAccount *r);
+void ndr_print_wbint_ChangeMachineAccount(struct ndr_print *ndr, const char *name, int flags, const struct wbint_ChangeMachineAccount *r);
 void ndr_print_wbint_SetMapping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_SetMapping *r);
 void ndr_print_wbint_RemoveMapping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_RemoveMapping *r);
 void ndr_print_wbint_SetHWM(struct ndr_print *ndr, const char *name, int flags, const struct wbint_SetHWM *r);

diff --git a/source3/librpc/gen_ndr/perfcount.h b/source3/librpc/gen_ndr/perfcount.h
new file mode 100644 (file)
index 0000000..cafce4f
--- /dev/null
+++ b/source3/librpc/gen_ndr/perfcount.h
@@ -0,0 +1,129 @@
+/* header auto-generated by pidl */
+
+#include <stdint.h>
+
+#include "libcli/util/ntstatus.h"
+
+#ifndef _HEADER_perfcount
+#define _HEADER_perfcount
+
+#define PERF_NO_INSTANCES      ( -1 )
+#define PERF_NO_UNIQUE_ID      ( -1 )
+#define PERF_SIZE_DWORD        ( 0x00000000 )
+#define PERF_SIZE_LARGE        ( 0x00000100 )
+#define PERF_SIZE_ZERO ( 0x00000200 )
+#define PERF_SIZE_VARIABLE_LEN ( 0x00000300 )
+#define PERF_TYPE_NUMBER       ( 0x00000000 )
+#define PERF_TYPE_COUNTER      ( 0x00000400 )
+#define PERF_TYPE_TEXT ( 0x00000800 )
+#define PERF_TYPE_ZERO ( 0x00000C00 )
+#define PERF_NUMBER_HEX        ( 0x00000000 )
+#define PERF_NUMBER_DECIMAL    ( 0x00010000 )
+#define PERF_NUMBER_DEC_1000   ( 0x00020000 )
+#define PERF_COUNTER_VALUE     ( 0x00000000 )
+#define PERF_COUNTER_RATE      ( 0x00010000 )
+#define PERF_COUNTER_FRACTION  ( 0x00020000 )
+#define PERF_COUNTER_BASE      ( 0x00030000 )
+#define PERF_COUNTER_ELAPSED   ( 0x00040000 )
+#define PERF_COUNTER_QUEUELEN  ( 0x00050000 )
+#define PERF_COUNTER_HISTOGRAM ( 0x00060000 )
+#define PERF_COUNTER_PRECISION ( 0x00070000 )
+#define PERF_TEXT_UNICODE      ( 0x00000000 )
+#define PERF_TEXT_ASCII        ( 0x00010000 )
+#define PERF_TIMER_TICK        ( 0x00000000 )
+#define PERF_TIMER_100NS       ( 0x00100000 )
+#define PERF_OBJECT_TIMER      ( 0x00200000 )
+#define PERF_DELTA_COUNTER     ( 0x00400000 )
+#define PERF_DELTA_BASE        ( 0x00800000 )
+#define PERF_INVERSE_COUNTER   ( 0x01000000 )
+#define PERF_MULTI_COUNTER     ( 0x02000000 )
+#define PERF_DISPLAY_NO_SUFFIX ( 0x00000000 )
+#define PERF_DISPLAY_PER_SEC   ( 0x10000000 )
+#define PERF_DISPLAY_PERCENT   ( 0x20000000 )
+#define PERF_DISPLAY_SECONDS   ( 0x30000000 )
+#define PERF_DISPLAY_NOSHOW    ( 0x40000000 )
+#define PERF_DETAIL_NOVICE     ( 100 )
+#define PERF_DETAIL_ADVANCED   ( 200 )
+#define PERF_DETAIL_EXPERT     ( 300 )
+#define PERF_DETAIL_WIZARD     ( 400 )
+struct SYSTEMTIME {
+       uint16_t year;
+       uint16_t month;
+       uint16_t dayofweek;
+       uint16_t day;
+       uint16_t hour;
+       uint16_t minute;
+       uint16_t second;
+       uint16_t milliseconds;
+};
+
+struct PERF_COUNTER_DEFINITION {
+       uint32_t ByteLength;
+       uint32_t CounterNameTitleIndex;
+       uint32_t CounterNameTitlePointer;
+       uint32_t CounterHelpTitleIndex;
+       uint32_t CounterHelpTitlePointer;
+       uint32_t DefaultScale;
+       uint32_t DetailLevel;
+       uint32_t CounterType;
+       uint32_t CounterSize;
+       uint32_t CounterOffset;
+}/* [public] */;
+
+struct PERF_COUNTER_BLOCK {
+       uint32_t ByteLength;
+       uint8_t *data;
+}/* [public] */;
+
+struct PERF_INSTANCE_DEFINITION {
+       uint32_t ByteLength;
+       uint32_t ParentObjectTitleIndex;
+       uint32_t ParentObjectTitlePointer;
+       uint32_t UniqueID;
+       uint32_t NameOffset;
+       uint32_t NameLength;
+       uint8_t *data;/* [unique] */
+       struct PERF_COUNTER_BLOCK counter_data;
+}/* [public] */;
+
+struct PERF_OBJECT_TYPE {
+       uint32_t TotalByteLength;
+       uint32_t DefinitionLength;
+       uint32_t HeaderLength;
+       uint32_t ObjectNameTitleIndex;
+       uint32_t ObjectNameTitlePointer;
+       uint32_t ObjectHelpTitleIndex;
+       uint32_t ObjectHelpTitlePointer;
+       uint32_t DetailLevel;
+       uint32_t NumCounters;
+       uint32_t DefaultCounter;
+       uint32_t NumInstances;
+       uint32_t CodePage;
+       uint64_t PerfTime;
+       uint64_t PerfFreq;
+       struct PERF_COUNTER_DEFINITION *counters;
+       struct PERF_INSTANCE_DEFINITION *instances;
+       struct PERF_COUNTER_BLOCK counter_data;
+}/* [public] */;
+
+struct PERF_DATA_BLOCK {
+       uint16_t Signature[4];
+       uint32_t LittleEndian;
+       uint32_t Version;
+       uint32_t Revision;
+       uint32_t TotalByteLength;
+       uint32_t HeaderLength;
+       uint32_t NumObjectTypes;
+       uint32_t DefaultObject;
+       struct SYSTEMTIME SystemTime;
+       uint32_t Padding;
+       uint64_t PerfTime;
+       uint64_t PerfFreq;
+       uint64_t PerfTime100nSec;
+       uint32_t SystemNameLength;
+       uint32_t SystemNameOffset;
+       uint8_t *data;/* [unique] */
+       struct PERF_OBJECT_TYPE *objects;
+}/* [public] */;
+
+#endif /* _HEADER_perfcount */

diff --git a/source3/librpc/gen_ndr/srv_wbint.c b/source3/librpc/gen_ndr/srv_wbint.c
index b3b535bc9cbe52c185cb1f2d6bff2a25965c9e89..0f39cd93e19d0e5335ae944f8a587d169c67c270 100644 (file)
--- a/source3/librpc/gen_ndr/srv_wbint.c
+++ b/source3/librpc/gen_ndr/srv_wbint.c
@@ -1537,6 +1537,79 @@ static bool api_wbint_CheckMachineAccount(pipes_struct *p)
        return true;
 }
 
+static bool api_wbint_ChangeMachineAccount(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct wbint_ChangeMachineAccount *r;
+
+       call = &ndr_table_wbint.calls[NDR_WBINT_CHANGEMACHINEACCOUNT];
+
+       r = talloc(talloc_tos(), struct wbint_ChangeMachineAccount);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(wbint_ChangeMachineAccount, r);
+       }
+
+       r->out.result = _wbint_ChangeMachineAccount(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(wbint_ChangeMachineAccount, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
 static bool api_wbint_SetMapping(pipes_struct *p)
 {
        const struct ndr_interface_call *call;
@@ -1779,6 +1852,7 @@ static struct api_struct api_wbint_cmds[] =
        {"WBINT_DSGETDCNAME", NDR_WBINT_DSGETDCNAME, api_wbint_DsGetDcName},
        {"WBINT_LOOKUPRIDS", NDR_WBINT_LOOKUPRIDS, api_wbint_LookupRids},
        {"WBINT_CHECKMACHINEACCOUNT", NDR_WBINT_CHECKMACHINEACCOUNT, api_wbint_CheckMachineAccount},
+       {"WBINT_CHANGEMACHINEACCOUNT", NDR_WBINT_CHANGEMACHINEACCOUNT, api_wbint_ChangeMachineAccount},
        {"WBINT_SETMAPPING", NDR_WBINT_SETMAPPING, api_wbint_SetMapping},
        {"WBINT_REMOVEMAPPING", NDR_WBINT_REMOVEMAPPING, api_wbint_RemoveMapping},
        {"WBINT_SETHWM", NDR_WBINT_SETHWM, api_wbint_SetHWM},
@@ -2035,6 +2109,12 @@ NTSTATUS rpc_wbint_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, co
                        return NT_STATUS_OK;
                }
 
+               case NDR_WBINT_CHANGEMACHINEACCOUNT: {
+                       struct wbint_ChangeMachineAccount *r = (struct wbint_ChangeMachineAccount *)_r;
+                       r->out.result = _wbint_ChangeMachineAccount(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
                case NDR_WBINT_SETMAPPING: {
                        struct wbint_SetMapping *r = (struct wbint_SetMapping *)_r;
                        r->out.result = _wbint_SetMapping(cli->pipes_struct, r);

diff --git a/source3/librpc/gen_ndr/srv_wbint.h b/source3/librpc/gen_ndr/srv_wbint.h
index 70738fcacf964ab24472a556ac13016bb6798109..c8c04fb3cc6b4712b5d390b2b19f1aeb82c741d8 100644 (file)
--- a/source3/librpc/gen_ndr/srv_wbint.h
+++ b/source3/librpc/gen_ndr/srv_wbint.h
@@ -20,6 +20,7 @@ NTSTATUS _wbint_QueryGroupList(pipes_struct *p, struct wbint_QueryGroupList *r);
 NTSTATUS _wbint_DsGetDcName(pipes_struct *p, struct wbint_DsGetDcName *r);
 NTSTATUS _wbint_LookupRids(pipes_struct *p, struct wbint_LookupRids *r);
 NTSTATUS _wbint_CheckMachineAccount(pipes_struct *p, struct wbint_CheckMachineAccount *r);
+NTSTATUS _wbint_ChangeMachineAccount(pipes_struct *p, struct wbint_ChangeMachineAccount *r);
 NTSTATUS _wbint_SetMapping(pipes_struct *p, struct wbint_SetMapping *r);
 NTSTATUS _wbint_RemoveMapping(pipes_struct *p, struct wbint_RemoveMapping *r);
 NTSTATUS _wbint_SetHWM(pipes_struct *p, struct wbint_SetHWM *r);
@@ -44,6 +45,7 @@ NTSTATUS _wbint_QueryGroupList(pipes_struct *p, struct wbint_QueryGroupList *r);
 NTSTATUS _wbint_DsGetDcName(pipes_struct *p, struct wbint_DsGetDcName *r);
 NTSTATUS _wbint_LookupRids(pipes_struct *p, struct wbint_LookupRids *r);
 NTSTATUS _wbint_CheckMachineAccount(pipes_struct *p, struct wbint_CheckMachineAccount *r);
+NTSTATUS _wbint_ChangeMachineAccount(pipes_struct *p, struct wbint_ChangeMachineAccount *r);
 NTSTATUS _wbint_SetMapping(pipes_struct *p, struct wbint_SetMapping *r);
 NTSTATUS _wbint_RemoveMapping(pipes_struct *p, struct wbint_RemoveMapping *r);
 NTSTATUS _wbint_SetHWM(pipes_struct *p, struct wbint_SetHWM *r);

diff --git a/source3/librpc/gen_ndr/wbint.h b/source3/librpc/gen_ndr/wbint.h
index 894e851ed129da5297c0dd180928282f97bd824d..1c6cdbc219952040fa2404bcbe25fcd297d32933 100644 (file)
--- a/source3/librpc/gen_ndr/wbint.h
+++ b/source3/librpc/gen_ndr/wbint.h
@@ -294,6 +294,14 @@ struct wbint_CheckMachineAccount {
 };
 
 
+struct wbint_ChangeMachineAccount {
+       struct {
+               NTSTATUS result;
+       } out;
+
+};
+
+
 struct wbint_SetMapping {
        struct {
                struct dom_sid *sid;/* [ref] */

diff --git a/source3/librpc/idl/libnetapi.idl b/source3/librpc/idl/libnetapi.idl
index 54e1bff8abeac3d7276107b61762bdf108a23365..593ee1c560381a99506751e1b3a8df9abcc7616b 100644 (file)
--- a/source3/librpc/idl/libnetapi.idl
+++ b/source3/librpc/idl/libnetapi.idl
@@ -1870,4 +1870,53 @@ interface libnetapi
                [in] string server_name
        );
 
+       /*******************************************/
+       /* I_NetLogonControl                       */
+       /*******************************************/
+
+       typedef struct {
+               uint32 netlog1_flags;
+               NET_API_STATUS netlog1_pdc_connection_status;
+       } NETLOGON_INFO_1;
+
+       typedef struct {
+               uint32 netlog2_flags;
+               NET_API_STATUS netlog2_pdc_connection_status;
+               string netlog2_trusted_dc_name;
+               NET_API_STATUS netlog2_tc_connection_status;
+       } NETLOGON_INFO_2;
+
+       typedef struct {
+               uint32 netlog1_flags;
+               uint32 netlog3_logon_attempts;
+               uint32 netlog3_reserved1;
+               uint32 netlog3_reserved2;
+               uint32 netlog3_reserved3;
+               uint32 netlog3_reserved4;
+               uint32 netlog3_reserved5;
+       } NETLOGON_INFO_3;
+
+       typedef struct {
+               string netlog4_trusted_dc_name;
+               string netlog4_trusted_domain_name;
+       } NETLOGON_INFO_4;
+
+       [nopush,nopull] NET_API_STATUS I_NetLogonControl(
+               [in] string server_name,
+               [in] uint32 function_code,
+               [in] uint32 query_level,
+               [out,ref] uint8 **buffer
+       );
+
+       /*******************************************/
+       /* I_NetLogonControl2                      */
+       /*******************************************/
+
+       [nopush,nopull] NET_API_STATUS I_NetLogonControl2(
+               [in] string server_name,
+               [in] uint32 function_code,
+               [in] uint32 query_level,
+               [in] uint8 *data,
+               [out,ref] uint8 **buffer
+       );
 }

diff --git a/source3/librpc/idl/perfcount.idl b/source3/librpc/idl/perfcount.idl
new file mode 100644 (file)
index 0000000..e9a4383
--- /dev/null
+++ b/source3/librpc/idl/perfcount.idl
@@ -0,0 +1,172 @@
+#include "idl_types.h"
+
+/*
+   IDL structures for perfcount code
+*/
+
+[
+       pointer_default(unique)
+]
+       interface perfcount
+{
+       const int PERF_NO_INSTANCES             = -1;
+       const int PERF_NO_UNIQUE_ID             = -1;
+
+       /* These determine the data size */
+       const int PERF_SIZE_DWORD               = 0x00000000;
+       const int PERF_SIZE_LARGE               = 0x00000100;
+       const int PERF_SIZE_ZERO                = 0x00000200;
+       const int PERF_SIZE_VARIABLE_LEN        = 0x00000300;
+
+       /* These determine the usage of the counter */
+       const int PERF_TYPE_NUMBER              = 0x00000000;
+       const int PERF_TYPE_COUNTER             = 0x00000400;
+       const int PERF_TYPE_TEXT                = 0x00000800;
+       const int PERF_TYPE_ZERO                = 0x00000C00;
+
+       /* If PERF_TYPE_NUMBER was selected, these provide display information */
+       const int PERF_NUMBER_HEX               = 0x00000000;
+       const int PERF_NUMBER_DECIMAL           = 0x00010000;
+       const int PERF_NUMBER_DEC_1000          = 0x00020000;
+
+       /* If PERF_TYPE_COUNTER was selected, these provide display information */
+       const int PERF_COUNTER_VALUE            = 0x00000000;
+       const int PERF_COUNTER_RATE             = 0x00010000;
+       const int PERF_COUNTER_FRACTION         = 0x00020000;
+       const int PERF_COUNTER_BASE             = 0x00030000;
+       const int PERF_COUNTER_ELAPSED          = 0x00040000;
+       const int PERF_COUNTER_QUEUELEN         = 0x00050000;
+       const int PERF_COUNTER_HISTOGRAM        = 0x00060000;
+       const int PERF_COUNTER_PRECISION        = 0x00070000;
+
+       /* If PERF_TYPE_TEXT was selected, these provide display information */
+       const int PERF_TEXT_UNICODE             = 0x00000000;
+       const int PERF_TEXT_ASCII               = 0x00010000;
+
+       /* These provide information for which tick count to use when computing elapsed interval */
+       const int PERF_TIMER_TICK               = 0x00000000;
+       const int PERF_TIMER_100NS              = 0x00100000;
+       const int PERF_OBJECT_TIMER             = 0x00200000;
+
+       /* These affect how the data is manipulated prior to being displayed */
+       const int PERF_DELTA_COUNTER            = 0x00400000;
+       const int PERF_DELTA_BASE               = 0x00800000;
+       const int PERF_INVERSE_COUNTER          = 0x01000000;
+       const int PERF_MULTI_COUNTER            = 0x02000000;
+
+       /* These determine if any text gets added when the value is displayed */
+       const int PERF_DISPLAY_NO_SUFFIX        = 0x00000000;
+       const int PERF_DISPLAY_PER_SEC          = 0x10000000;
+       const int PERF_DISPLAY_PERCENT          = 0x20000000;
+       const int PERF_DISPLAY_SECONDS          = 0x30000000;
+       const int PERF_DISPLAY_NOSHOW           = 0x40000000;
+
+       /* These determine the DetailLevel of the counter */
+       const int PERF_DETAIL_NOVICE            = 100;
+       const int PERF_DETAIL_ADVANCED          = 200;
+       const int PERF_DETAIL_EXPERT            = 300;
+       const int PERF_DETAIL_WIZARD            = 400;
+
+       typedef struct {
+               uint16 year;
+               uint16 month;
+               uint16 dayofweek;
+               uint16 day;
+               uint16 hour;
+               uint16 minute;
+               uint16 second;
+               uint16 milliseconds;
+       } SYSTEMTIME;
+
+       typedef [public] struct {
+               /* sizeof(PERF_COUNTER_DEFINITION) */
+               uint32 ByteLength;
+               uint32 CounterNameTitleIndex;
+               uint32 CounterNameTitlePointer;
+               uint32 CounterHelpTitleIndex;
+               uint32 CounterHelpTitlePointer;
+               uint32 DefaultScale;
+               uint32 DetailLevel;
+               uint32 CounterType;
+               uint32 CounterSize;
+               uint32 CounterOffset;
+       } PERF_COUNTER_DEFINITION;
+
+       typedef [public] struct {
+               /* Total size of the data block, including all data plus this header */
+               uint32 ByteLength;
+               uint8 data[ByteLength];
+       } PERF_COUNTER_BLOCK;
+
+       typedef [public] struct {
+               /* Total size of the instance definition, including the length of the terminated Name string */
+               uint32 ByteLength;
+               uint32 ParentObjectTitleIndex;
+               uint32 ParentObjectTitlePointer;
+               uint32 UniqueID;
+               /* From the start of the PERF_INSTANCE_DEFINITION, the byte offset to the start of the Name string */
+               uint32 NameOffset;
+               uint32 NameLength;
+               /* Unicode string containing the name for the instance */
+               uint8 *data;
+               PERF_COUNTER_BLOCK counter_data;
+       } PERF_INSTANCE_DEFINITION;
+
+       typedef [public] struct {
+               /* Total size of the object block, including all PERF_INSTANCE_DEFINITIONs,
+                  PERF_COUNTER_DEFINITIONs and PERF_COUNTER_BLOCKs in bytes */
+               uint32 TotalByteLength;
+               /* Size of this PERF_OBJECT_TYPE plus all PERF_COUNTER_DEFINITIONs in bytes */
+               uint32 DefinitionLength;
+               /* Size of this PERF_OBJECT_TYPE */
+               uint32 HeaderLength;
+               uint32 ObjectNameTitleIndex;
+               uint32 ObjectNameTitlePointer;
+               uint32 ObjectHelpTitleIndex;
+               uint32 ObjectHelpTitlePointer;
+               uint32 DetailLevel;
+               uint32 NumCounters;
+               uint32 DefaultCounter;
+               uint32 NumInstances;
+               uint32 CodePage;
+               hyper PerfTime;
+               hyper PerfFreq;
+               PERF_COUNTER_DEFINITION counters[NumCounters];
+               PERF_INSTANCE_DEFINITION instances[NumInstances];
+               PERF_COUNTER_BLOCK counter_data;
+       } PERF_OBJECT_TYPE;
+
+       /* PerfCounter Inner Buffer structs */
+       typedef [public] struct {
+               /* hardcoded to read "P.E.R.F" */
+               uint16 Signature[4];
+               uint32 LittleEndian;
+               /* both currently hardcoded to 1 */
+               uint32 Version;
+               uint32 Revision;
+               /* bytes of PERF_OBJECT_TYPE data, does NOT include the PERF_DATA_BLOCK */
+               uint32 TotalByteLength;
+               /* size of PERF_DATA_BLOCK including the uint8 *data */
+               uint32 HeaderLength;
+               /* number of PERF_OBJECT_TYPE structures encoded */
+               uint32 NumObjectTypes;
+               uint32 DefaultObject;
+               SYSTEMTIME SystemTime;
+               /* This will guarantee that we're on a 64-bit boundary before we encode
+                  PerfTime, and having it there will make my offset math much easier. */
+               uint32 Padding;
+               /* Now when I'm marshalling this, I'll need to call prs_align_uint64()
+                  before I start encodint the uint64 structs */
+               /* clock rate * seconds uptime */
+               hyper PerfTime;
+               /* The clock rate of the CPU */
+               hyper PerfFreq;
+               /* used for high-res timers -- for now PerfTime * 10e7 */
+               hyper PerfTime100nSec;
+               uint32 SystemNameLength;
+               uint32 SystemNameOffset;
+               /* The SystemName, in unicode, terminated */
+               uint8* data;
+               PERF_OBJECT_TYPE objects[NumObjectTypes];
+       } PERF_DATA_BLOCK;
+}

diff --git a/source3/librpc/idl/wbint.idl b/source3/librpc/idl/wbint.idl
index af59cb6b75077888eda8547646f88a74ca67da6c..1f0192e73cd457bf68ddda2f6530af34de33208c 100644 (file)
--- a/source3/librpc/idl/wbint.idl
+++ b/source3/librpc/idl/wbint.idl
@@ -147,6 +147,9 @@ interface wbint
     NTSTATUS wbint_CheckMachineAccount(
        );
 
+    NTSTATUS wbint_ChangeMachineAccount(
+       );
+
     typedef [public] enum {
        WBINT_ID_TYPE_NOT_SPECIFIED,
        WBINT_ID_TYPE_UID,
@@ -169,4 +172,4 @@ interface wbint
        [in] wbint_IdType type,
        [in] hyper id
        );
-}
\ No newline at end of file
+}

diff --git a/source3/libsmb/clifile.c b/source3/libsmb/clifile.c
index b15aa8d998499a3fbad82134e0f5cf7b9c6edb50..5eb8bd471be1bbb50a7e7efd1f5d1bcea7bf6202 100644 (file)
--- a/source3/libsmb/clifile.c
+++ b/source3/libsmb/clifile.c
@@ -5027,3 +5027,147 @@ NTSTATUS cli_posix_rmdir(struct cli_state *cli, const char *fname)
        }
        return status;
 }
+
+/****************************************************************************
+ filechangenotify
+****************************************************************************/
+
+struct cli_notify_state {
+       uint8_t setup[8];
+       uint32_t num_changes;
+       struct notify_change *changes;
+};
+
+static void cli_notify_done(struct tevent_req *subreq);
+
+struct tevent_req *cli_notify_send(TALLOC_CTX *mem_ctx,
+                                  struct tevent_context *ev,
+                                  struct cli_state *cli, uint16_t fnum,
+                                  uint32_t buffer_size,
+                                  uint32_t completion_filter, bool recursive)
+{
+       struct tevent_req *req, *subreq;
+       struct cli_notify_state *state;
+
+       req = tevent_req_create(mem_ctx, &state, struct cli_notify_state);
+       if (req == NULL) {
+               return NULL;
+       }
+
+       SIVAL(state->setup, 0, completion_filter);
+       SSVAL(state->setup, 4, fnum);
+       SSVAL(state->setup, 6, recursive);
+
+       subreq = cli_trans_send(
+               state,                  /* mem ctx. */
+               ev,                     /* event ctx. */
+               cli,                    /* cli_state. */
+               SMBnttrans,             /* cmd. */
+               NULL,                   /* pipe name. */
+               -1,                     /* fid. */
+               NT_TRANSACT_NOTIFY_CHANGE, /* function. */
+               0,                      /* flags. */
+               (uint16_t *)state->setup, /* setup. */
+               4,                      /* num setup uint16_t words. */
+               0,                      /* max returned setup. */
+               NULL,                   /* param. */
+               0,                      /* num param. */
+               buffer_size,            /* max returned param. */
+               NULL,                   /* data. */
+               0,                      /* num data. */
+               0);                     /* max returned data. */
+
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, cli_notify_done, req);
+       return req;
+}
+
+static void cli_notify_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct cli_notify_state *state = tevent_req_data(
+               req, struct cli_notify_state);
+       NTSTATUS status;
+       uint8_t *params;
+       uint32_t i, ofs, num_params;
+
+       status = cli_trans_recv(subreq, talloc_tos(), NULL, NULL,
+                               &params, &num_params, NULL, NULL);
+       TALLOC_FREE(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_trans_recv returned %s\n", nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       state->num_changes = 0;
+       ofs = 0;
+
+       while (num_params - ofs > 12) {
+               uint32_t len = IVAL(params, ofs);
+               state->num_changes += 1;
+
+               if ((len == 0) || (ofs+len >= num_params)) {
+                       break;
+               }
+               ofs += len;
+       }
+
+       state->changes = talloc_array(state, struct notify_change,
+                                     state->num_changes);
+       if (tevent_req_nomem(state->changes, req)) {
+               TALLOC_FREE(params);
+               return;
+       }
+
+       ofs = 0;
+
+       for (i=0; i<state->num_changes; i++) {
+               uint32_t next = IVAL(params, ofs);
+               uint32_t len = IVAL(params, ofs+8);
+               ssize_t ret;
+               char *name;
+
+               if ((next != 0) && (len+12 != next)) {
+                       TALLOC_FREE(params);
+                       tevent_req_nterror(
+                               req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                       return;
+               }
+
+               state->changes[i].action = IVAL(params, ofs+4);
+               ret = clistr_pull_talloc(params, (char *)params, &name,
+                                        params+ofs+12, len,
+                                        STR_TERMINATE|STR_UNICODE);
+               if (ret == -1) {
+                       TALLOC_FREE(params);
+                       tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+                       return;
+               }
+               state->changes[i].name = name;
+               ofs += next;
+       }
+
+       TALLOC_FREE(params);
+       tevent_req_done(req);
+}
+
+NTSTATUS cli_notify_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                        uint32_t *pnum_changes,
+                        struct notify_change **pchanges)
+{
+       struct cli_notify_state *state = tevent_req_data(
+               req, struct cli_notify_state);
+       NTSTATUS status;
+
+       if (tevent_req_is_nterror(req, &status)) {
+               return status;
+       }
+
+       *pnum_changes = state->num_changes;
+       *pchanges = talloc_move(mem_ctx, &state->changes);
+       return NT_STATUS_OK;
+}

diff --git a/source3/libsmb/clikrb5.c b/source3/libsmb/clikrb5.c
index 152c23bd150c39f679ef563c8a2fecde0b3ab2ae..145e30beb3e14b115d630f7184baa8011d95280c 100644 (file)
--- a/source3/libsmb/clikrb5.c
+++ b/source3/libsmb/clikrb5.c
@@ -1858,6 +1858,15 @@ static krb5_error_code ads_krb5_get_fwd_ticket( krb5_context context,
        char *pChksum = NULL;
        char *p = NULL;
 
+/* MIT krb5 1.7beta3 (in Ubuntu Karmic) is missing the prototype,
+   but still has the symbol */
+#if !HAVE_DECL_KRB5_AUTH_CON_SET_REQ_CKSUMTYPE
+krb5_error_code krb5_auth_con_set_req_cksumtype(  
+       krb5_context     context,
+       krb5_auth_context      auth_context,  
+       krb5_cksumtype     cksumtype);
+#endif
+
        ZERO_STRUCT(fwdData);
        ZERO_STRUCTP(authenticator);
 

diff --git a/source3/libsmb/clispnego.c b/source3/libsmb/clispnego.c
index 5d7e43d941f79f20c7f78f8c5f7ac3fd8e3ac92e..e20749b3e8af57e4263409f67120d20b68bd6197 100644 (file)
--- a/source3/libsmb/clispnego.c
+++ b/source3/libsmb/clispnego.c
@@ -495,31 +495,28 @@ DATA_BLOB spnego_gen_auth(DATA_BLOB blob)
 */
 bool spnego_parse_auth(DATA_BLOB blob, DATA_BLOB *auth)
 {
-       ASN1_DATA *data;
+       ssize_t len;
+       struct spnego_data token;
 
-       data = asn1_init(talloc_tos());
-       if (data == NULL) {
+       len = spnego_read_data(talloc_tos(), blob, &token);
+       if (len == -1) {
+               DEBUG(3,("spnego_parse_auth: spnego_read_data failed\n"));
                return false;
        }
 
-       asn1_load(data, blob);
-       asn1_start_tag(data, ASN1_CONTEXT(1));
-       asn1_start_tag(data, ASN1_SEQUENCE(0));
-       asn1_start_tag(data, ASN1_CONTEXT(2));
-       asn1_read_OctetString(data, talloc_autofree_context(), auth);
-       asn1_end_tag(data);
-       asn1_end_tag(data);
-       asn1_end_tag(data);
-
-       if (data->has_error) {
-               DEBUG(3,("spnego_parse_auth failed at %d\n", (int)data->ofs));
-               data_blob_free(auth);
-               asn1_free(data);
-               return False;
+       if (token.type != SPNEGO_NEG_TOKEN_TARG) {
+               DEBUG(3,("spnego_parse_auth: wrong token type: %d\n",
+                       token.type));
+               spnego_free_data(&token);
+               return false;
        }
 
-       asn1_free(data);
-       return True;
+       *auth = data_blob_talloc(talloc_tos(),
+                                token.negTokenTarg.responseToken.data,
+                                token.negTokenTarg.responseToken.length);
+       spnego_free_data(&token);
+
+       return true;
 }
 
 /*

diff --git a/source3/libsmb/dsgetdcname.c b/source3/libsmb/dsgetdcname.c
index 98b65942e4df030ece242492245862aa8c2eda68..180547063a46a50ffbf5fc9e2b9469119984bd99 100644 (file)
--- a/source3/libsmb/dsgetdcname.c
+++ b/source3/libsmb/dsgetdcname.c
@@ -686,7 +686,7 @@ static NTSTATUS make_domain_controller_info(TALLOC_CTX *mem_ctx,
        if (forest_name && *forest_name) {
                info->forest_name = talloc_strdup(mem_ctx, forest_name);
                NT_STATUS_HAVE_NO_MEMORY(info->forest_name);
-               flags |= DS_DNS_FOREST;
+               flags |= DS_DNS_FOREST_ROOT;
        }
 
        info->dc_flags = flags;

diff --git a/source3/libsmb/trusts_util.c b/source3/libsmb/trusts_util.c
index 929816e92d29d85cbf3f18cbb7413d9629d725eb..584217d3f187b64356de738e9995a0d7695a9bdf 100644 (file)
--- a/source3/libsmb/trusts_util.c
+++ b/source3/libsmb/trusts_util.c
@@ -29,13 +29,22 @@
 
 NTSTATUS trust_pw_change_and_store_it(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, 
                                      const char *domain,
+                                     const char *account_name,
                                      unsigned char orig_trust_passwd_hash[16],
-                                     uint32 sec_channel_type)
+                                     enum netr_SchannelType sec_channel_type)
 {
        unsigned char new_trust_passwd_hash[16];
        char *new_trust_passwd;
        NTSTATUS nt_status;
-               
+
+       switch (sec_channel_type) {
+       case SEC_CHAN_WKSTA:
+       case SEC_CHAN_DOMAIN:
+               break;
+       default:
+               return NT_STATUS_NOT_SUPPORTED;
+       }
+
        /* Create a random machine account password */
        new_trust_passwd = generate_random_str(mem_ctx, DEFAULT_TRUST_ACCOUNT_PASSWORD_LENGTH);
 
@@ -43,15 +52,16 @@ NTSTATUS trust_pw_change_and_store_it(struct rpc_pipe_client *cli, TALLOC_CTX *m
                DEBUG(0, ("talloc_strdup failed\n"));
                return NT_STATUS_NO_MEMORY;
        }
-       
+
        E_md4hash(new_trust_passwd, new_trust_passwd_hash);
 
        nt_status = rpccli_netlogon_set_trust_password(cli, mem_ctx,
+                                                      account_name,
                                                       orig_trust_passwd_hash,
                                                       new_trust_passwd,
                                                       new_trust_passwd_hash,
                                                       sec_channel_type);
-       
+
        if (NT_STATUS_IS_OK(nt_status)) {
                DEBUG(3,("%s : trust_pw_change_and_store_it: Changed password.\n", 
                         current_timestring(debug_ctx(), False)));
@@ -59,8 +69,33 @@ NTSTATUS trust_pw_change_and_store_it(struct rpc_pipe_client *cli, TALLOC_CTX *m
                 * Return the result of trying to write the new password
                 * back into the trust account file.
                 */
-               if (!secrets_store_machine_password(new_trust_passwd, domain, sec_channel_type)) {
-                       nt_status = NT_STATUS_UNSUCCESSFUL;
+
+               switch (sec_channel_type) {
+
+               case SEC_CHAN_WKSTA:
+                       if (!secrets_store_machine_password(new_trust_passwd, domain, sec_channel_type)) {
+                               nt_status = NT_STATUS_UNSUCCESSFUL;
+                       }
+                       break;
+
+               case SEC_CHAN_DOMAIN: {
+                       char *pwd;
+                       struct dom_sid sid;
+                       time_t pass_last_set_time;
+
+                       /* we need to get the sid first for the
+                        * pdb_set_trusteddom_pw call */
+
+                       if (!pdb_get_trusteddom_pw(domain, &pwd, &sid, &pass_last_set_time)) {
+                               nt_status = NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE;
+                       }
+                       if (!pdb_set_trusteddom_pw(domain, new_trust_passwd, &sid)) {
+                               nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                       }
+                       break;
+               }
+               default:
+                       break;
                }
        }
 
@@ -78,16 +113,17 @@ NTSTATUS trust_pw_find_change_and_store_it(struct rpc_pipe_client *cli,
                                           const char *domain) 
 {
        unsigned char old_trust_passwd_hash[16];
-       uint32 sec_channel_type = 0;
+       enum netr_SchannelType sec_channel_type = SEC_CHAN_NULL;
+       const char *account_name;
 
-       if (!secrets_fetch_trust_account_password(domain,
-                                                 old_trust_passwd_hash, 
-                                                 NULL, &sec_channel_type)) {
+       if (!get_trust_pw_hash(domain, old_trust_passwd_hash, &account_name,
+                              &sec_channel_type)) {
                DEBUG(0, ("could not fetch domain secrets for domain %s!\n", domain));
                return NT_STATUS_UNSUCCESSFUL;
        }
-       
+
        return trust_pw_change_and_store_it(cli, mem_ctx, domain,
+                                           account_name,
                                            old_trust_passwd_hash,
                                            sec_channel_type);
 }

diff --git a/source3/locale/net/de.po b/source3/locale/net/de.po
index d99873b11d2336f78c36129fa9d8b24d8e003fe2..a3369363435b9eb99e4ef14fc25e2368356be0ff 100644 (file)
--- a/source3/locale/net/de.po
+++ b/source3/locale/net/de.po
@@ -378,14 +378,6 @@ msgstr ""
 msgid "  Use 'net help registry' to get more information about 'net registry' commands."
 msgstr ""
 
-#: ../../utils/net.c:584
-msgid "Open a lua interpreter"
-msgstr ""
-
-#: ../../utils/net.c:585
-msgid "  Use 'net help lua' to get more information about 'net lua' commands."
-msgstr ""
-
 #: ../../utils/net.c:591
 msgid "Process Win32 *.evt eventlog files"
 msgstr ""
@@ -3369,62 +3361,6 @@ msgid ""
 "Usage: \n"
 msgstr ""
 
-#: ../../utils/net_lua.c:60
-msgid "connect: Expected IP-Address"
-msgstr ""
-
-#: ../../utils/net_lua.c:65
-msgid "connect: Expected port"
-msgstr ""
-
-#: ../../utils/net_lua.c:84
-#, c-format
-msgid "connect failed: %s"
-msgstr ""
-
-#: ../../utils/net_lua.c:132
-#, c-format
-msgid "socket domain %s unknown"
-msgstr ""
-
-#: ../../utils/net_lua.c:144
-#, c-format
-msgid "socket type %s unknown"
-msgstr ""
-
-#: ../../utils/net_lua.c:155
-#, c-format
-msgid "socket() failed: %s"
-msgstr ""
-
-#: ../../utils/net_lua.c:278
-msgid "evt_reference_thread failed\n"
-msgstr ""
-
-#: ../../utils/net_lua.c:287
-msgid "event_add_timed failed"
-msgstr ""
-
-#: ../../utils/net_lua.c:300
-msgid "event_once called from non-base thread"
-msgstr ""
-
-#: ../../utils/net_lua.c:323
-msgid "event_context_init failed"
-msgstr ""
-
-#: ../../utils/net_lua.c:353
-msgid "lua_newstate failed\n"
-msgstr ""
-
-#: ../../utils/net_lua.c:371
-msgid "luaL_dofile returned an error\n"
-msgstr ""
-
-#: ../../utils/net_lua.c:376
-msgid "luaL_dostring returned an error\n"
-msgstr ""
-
 #: ../../utils/net_rap.c:39
 msgid ""
 "\n"

diff --git a/source3/locale/net/genmsg b/source3/locale/net/genmsg
index 7202e8108e4d19be02edb1c2d20964ace4f37cfd..fcae0e7fe64c258168393a9b2b08bbf5b9c5cddb 100755 (executable)
--- a/source3/locale/net/genmsg
+++ b/source3/locale/net/genmsg
@@ -29,7 +29,7 @@ add_basedir_to_filelist() {
 FILES=`add_basedir_to_filelist ../../utils net.c net_ads.c net_ads_gpo.c \
        net_afs.c net_cache.c net_conf.c net_dom.c net_eventlog.c net_file.c \
        net_group.c net_groupmap.c net_help.c net_help_common.c net_idmap.c \
-       net_join.c net_lookup.c net_lua.c net_rap.c net_registry.c \
+       net_join.c net_lookup.c net_rap.c net_registry.c \
        net_registry_util.c net_rpc.c net_rpc_audit.c net_rpc_join.c \
        net_rpc_printer.c net_rpc_registry.c net_rpc_rights.c net_rpc_samsync.c \
        net_rpc_service.c net_rpc_sh_acct.c net_rpc_shell.c net_sam.c \

diff --git a/source3/locking/brlock.c b/source3/locking/brlock.c
index 05d6c7f95d09fa9eb21f949f3fb0d73691d93e51..18a798182b957048310287bfc275701b9e310e6f 100644 (file)
--- a/source3/locking/brlock.c
+++ b/source3/locking/brlock.c
@@ -390,10 +390,9 @@ NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
  Cope with POSIX range splits and merges.
 ****************************************************************************/
 
-static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,              /* Output array. */
-                                               const struct lock_struct *ex,           /* existing lock. */
-                                               const struct lock_struct *plock,        /* proposed lock. */
-                                               bool *lock_was_added)
+static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,      /* Output array. */
+                                               struct lock_struct *ex,         /* existing lock. */
+                                               struct lock_struct *plock)      /* proposed lock. */
 {
        bool lock_types_differ = (ex->lock_type != plock->lock_type);
 
@@ -410,21 +409,23 @@ static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,         /* Ou
        /* Did we overlap ? */
 
 /*********************************************
-                                             +---------+
-                                             | ex      |
-                                             +---------+
-                              +-------+
-                              | plock |
-                              +-------+
+                                        +---------+
+                                        | ex      |
+                                        +---------+
+                         +-------+
+                         | plock |
+                         +-------+
 OR....
-             +---------+
-             |  ex     |
-             +---------+
+        +---------+
+        |  ex     |
+        +---------+
 **********************************************/
 
        if ( (ex->start > (plock->start + plock->size)) ||
-                       (plock->start > (ex->start + ex->size))) {
+               (plock->start > (ex->start + ex->size))) {
+
                /* No overlap with this lock - copy existing. */
+
                memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
                return 1;
        }
@@ -436,26 +437,109 @@ OR....
         +---------------------------+
         |       plock               | -> replace with plock.
         +---------------------------+
+OR
+             +---------------+
+             |       ex      |
+             +---------------+
+        +---------------------------+
+        |       plock               | -> replace with plock.
+        +---------------------------+
+
 **********************************************/
 
        if ( (ex->start >= plock->start) &&
-                       (ex->start + ex->size <= plock->start + plock->size) ) {
-               memcpy(&lck_arr[0], plock, sizeof(struct lock_struct));
-               *lock_was_added = True;
-               return 1;
+               (ex->start + ex->size <= plock->start + plock->size) ) {
+
+               /* Replace - discard existing lock. */
+
+               return 0;
        }
 
 /*********************************************
+Adjacent after.
+                        +-------+
+                        |  ex   |
+                        +-------+
+        +---------------+
+        |   plock       |
+        +---------------+
+
+BECOMES....
+        +---------------+-------+
+        |   plock       | ex    | - different lock types.
+        +---------------+-------+
+OR.... (merge)
+        +-----------------------+
+        |   plock               | - same lock type.
+        +-----------------------+
+**********************************************/
+
+       if (plock->start + plock->size == ex->start) {
+
+               /* If the lock types are the same, we merge, if different, we
+                  add the remainder of the old lock. */
+
+               if (lock_types_differ) {
+                       /* Add existing. */
+                       memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
+                       return 1;
+               } else {
+                       /* Merge - adjust incoming lock as we may have more
+                        * merging to come. */
+                       plock->size += ex->size;
+                       return 0;
+               }
+       }
+
+/*********************************************
+Adjacent before.
+        +-------+
+        |  ex   |
+        +-------+
+                +---------------+
+                |   plock       |
+                +---------------+
+BECOMES....
+        +-------+---------------+
+        | ex    |   plock       | - different lock types
+        +-------+---------------+
+
+OR.... (merge)
+        +-----------------------+
+        |      plock            | - same lock type.
+        +-----------------------+
+
+**********************************************/
+
+       if (ex->start + ex->size == plock->start) {
+
+               /* If the lock types are the same, we merge, if different, we
+                  add the existing lock. */
+
+               if (lock_types_differ) {
+                       memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
+                       return 1;
+               } else {
+                       /* Merge - adjust incoming lock as we may have more
+                        * merging to come. */
+                       plock->start = ex->start;
+                       plock->size += ex->size;
+                       return 0;
+               }
+       }
+
+/*********************************************
+Overlap after.
         +-----------------------+
         |          ex           |
         +-----------------------+
         +---------------+
         |   plock       |
         +---------------+
-OR....
-                        +-------+
-                        |  ex   |
-                        +-------+
+OR
+               +----------------+
+               |       ex       |
+               +----------------+
         +---------------+
         |   plock       |
         +---------------+
@@ -466,60 +550,57 @@ BECOMES....
         +---------------+-------+
 OR.... (merge)
         +-----------------------+
-        |   ex                  | - same lock type.
+        |   plock               | - same lock type.
         +-----------------------+
 **********************************************/
 
        if ( (ex->start >= plock->start) &&
-                               (ex->start <= plock->start + plock->size) &&
-                               (ex->start + ex->size > plock->start + plock->size) ) {
-
-               *lock_was_added = True;
+               (ex->start <= plock->start + plock->size) &&
+               (ex->start + ex->size > plock->start + plock->size) ) {
 
                /* If the lock types are the same, we merge, if different, we
-                  add the new lock before the old. */
+                  add the remainder of the old lock. */
 
                if (lock_types_differ) {
-                       /* Add new. */
-                       memcpy(&lck_arr[0], plock, sizeof(struct lock_struct));
-                       memcpy(&lck_arr[1], ex, sizeof(struct lock_struct));
+                       /* Add remaining existing. */
+                       memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
                        /* Adjust existing start and size. */
-                       lck_arr[1].start = plock->start + plock->size;
-                       lck_arr[1].size = (ex->start + ex->size) - (plock->start + plock->size);
-                       return 2;
-               } else {
-                       /* Merge. */
-                       memcpy(&lck_arr[0], plock, sizeof(struct lock_struct));
-                       /* Set new start and size. */
-                       lck_arr[0].start = plock->start;
-                       lck_arr[0].size = (ex->start + ex->size) - plock->start;
+                       lck_arr[0].start = plock->start + plock->size;
+                       lck_arr[0].size = (ex->start + ex->size) - (plock->start + plock->size);
                        return 1;
+               } else {
+                       /* Merge - adjust incoming lock as we may have more
+                        * merging to come. */
+                       plock->size += (ex->start + ex->size) - (plock->start + plock->size);
+                       return 0;
                }
        }
 
 /*********************************************
-   +-----------------------+
-   |  ex                   |
-   +-----------------------+
-           +---------------+
-           |   plock       |
-           +---------------+
-OR....
-   +-------+        
-   |  ex   |
-   +-------+
-           +---------------+
-           |   plock       |
-           +---------------+
+Overlap before.
+        +-----------------------+
+        |  ex                   |
+        +-----------------------+
+                +---------------+
+                |   plock       |
+                +---------------+
+OR
+        +-------------+
+        |  ex         |
+        +-------------+
+                +---------------+
+                |   plock       |
+                +---------------+
+
 BECOMES....
-   +-------+---------------+
-   | ex    |   plock       | - different lock types
-   +-------+---------------+
+        +-------+---------------+
+        | ex    |   plock       | - different lock types
+        +-------+---------------+
 
 OR.... (merge)
-   +-----------------------+
-   | ex                    | - same lock type.
-   +-----------------------+
+        +-----------------------+
+        |      plock            | - same lock type.
+        +-----------------------+
 
 **********************************************/
 
@@ -527,27 +608,25 @@ OR.... (merge)
                        (ex->start + ex->size >= plock->start) &&
                        (ex->start + ex->size <= plock->start + plock->size) ) {
 
-               *lock_was_added = True;
-
                /* If the lock types are the same, we merge, if different, we
-                  add the new lock after the old. */
+                  add the truncated old lock. */
 
                if (lock_types_differ) {
                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                       memcpy(&lck_arr[1], plock, sizeof(struct lock_struct));
                        /* Adjust existing size. */
                        lck_arr[0].size = plock->start - ex->start;
-                       return 2;
-               } else {
-                       /* Merge. */
-                       memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                       /* Adjust existing size. */
-                       lck_arr[0].size = (plock->start + plock->size) - ex->start;
                        return 1;
+               } else {
+                       /* Merge - adjust incoming lock as we may have more
+                        * merging to come. MUST ADJUST plock SIZE FIRST ! */
+                       plock->size += (plock->start - ex->start);
+                       plock->start = ex->start;
+                       return 0;
                }
        }
 
 /*********************************************
+Complete overlap.
         +---------------------------+
         |        ex                 |
         +---------------------------+
@@ -560,32 +639,31 @@ BECOMES.....
         +-------+---------+---------+
 OR
         +---------------------------+
-        |        ex                 | - same lock type.
+        |        plock              | - same lock type.
         +---------------------------+
 **********************************************/
 
        if ( (ex->start < plock->start) && (ex->start + ex->size > plock->start + plock->size) ) {
-               *lock_was_added = True;
 
                if (lock_types_differ) {
 
                        /* We have to split ex into two locks here. */
 
                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                       memcpy(&lck_arr[1], plock, sizeof(struct lock_struct));
-                       memcpy(&lck_arr[2], ex, sizeof(struct lock_struct));
+                       memcpy(&lck_arr[1], ex, sizeof(struct lock_struct));
 
                        /* Adjust first existing size. */
                        lck_arr[0].size = plock->start - ex->start;
 
                        /* Adjust second existing start and size. */
-                       lck_arr[2].start = plock->start + plock->size;
-                       lck_arr[2].size = (ex->start + ex->size) - (plock->start + plock->size);
-                       return 3;
+                       lck_arr[1].start = plock->start + plock->size;
+                       lck_arr[1].size = (ex->start + ex->size) - (plock->start + plock->size);
+                       return 2;
                } else {
-                       /* Just eat plock. */
-                       memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                       return 1;
+                       /* Just eat the existing locks, merge them into plock. */
+                       plock->start = ex->start;
+                       plock->size = ex->size;
+                       return 0;
                }
        }
 
@@ -609,7 +687,6 @@ static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
        unsigned int i, count, posix_count;
        struct lock_struct *locks = br_lck->lock_data;
        struct lock_struct *tp;
-       bool lock_was_added = False;
        bool signal_pending_read = False;
        bool break_oplocks = false;
        NTSTATUS status;
@@ -633,8 +710,9 @@ static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
        if (!tp) {
                return NT_STATUS_NO_MEMORY;
        }
-       
+
        count = posix_count = 0;
+
        for (i=0; i < br_lck->num_locks; i++) {
                struct lock_struct *curr_lock = &locks[i];
 
@@ -671,7 +749,7 @@ static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
                        }
 
                        /* Work out overlaps. */
-                       tmp_count += brlock_posix_split_merge(&tp[count], curr_lock, plock, &lock_was_added);
+                       tmp_count += brlock_posix_split_merge(&tp[count], curr_lock, plock);
                        posix_count += tmp_count;
                        count += tmp_count;
                }
@@ -692,10 +770,21 @@ static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
                                             LEVEL2_CONTEND_POSIX_BRL);
        }
 
-       if (!lock_was_added) {
-               memcpy(&tp[count], plock, sizeof(struct lock_struct));
-               count++;
+       /* Try and add the lock in order, sorted by lock start. */
+       for (i=0; i < count; i++) {
+               struct lock_struct *curr_lock = &tp[i];
+
+               if (curr_lock->start <= plock->start) {
+                       continue;
+               }
+       }
+
+       if (i < count) {
+               memmove(&tp[i+1], &tp[i],
+                       (count - i)*sizeof(struct lock_struct));
        }
+       memcpy(&tp[i], plock, sizeof(struct lock_struct));
+       count++;
 
        /* We can get the POSIX lock, now see if it needs to
           be mapped into a lower level POSIX one, and if so can
@@ -729,12 +818,16 @@ static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
                }
        }
 
-       /* Realloc so we don't leak entries per lock call. */
-       tp = (struct lock_struct *)SMB_REALLOC(tp, count * sizeof(*locks));
-       if (!tp) {
-               status = NT_STATUS_NO_MEMORY;
-               goto fail;
+       /* If we didn't use all the allocated size,
+        * Realloc so we don't leak entries per lock call. */
+       if (count < br_lck->num_locks + 2) {
+               tp = (struct lock_struct *)SMB_REALLOC(tp, count * sizeof(*locks));
+               if (!tp) {
+                       status = NT_STATUS_NO_MEMORY;
+                       goto fail;
+               }
        }
+
        br_lck->num_locks = count;
        SAFE_FREE(br_lck->lock_data);
        br_lck->lock_data = tp;
@@ -955,9 +1048,9 @@ bool brl_unlock_windows_default(struct messaging_context *msg_ctx,
 
 static bool brl_unlock_posix(struct messaging_context *msg_ctx,
                             struct byte_range_lock *br_lck,
-                            const struct lock_struct *plock)
+                            struct lock_struct *plock)
 {
-       unsigned int i, j, count, posix_count;
+       unsigned int i, j, count;
        struct lock_struct *tp;
        struct lock_struct *locks = br_lck->lock_data;
        bool overlap_found = False;
@@ -984,11 +1077,9 @@ static bool brl_unlock_posix(struct messaging_context *msg_ctx,
                return False;
        }
 
-       count = posix_count = 0;
+       count = 0;
        for (i = 0; i < br_lck->num_locks; i++) {
                struct lock_struct *lock = &locks[i];
-               struct lock_struct tmp_lock[3];
-               bool lock_was_added = False;
                unsigned int tmp_count;
 
                /* Only remove our own locks - ignore fnum. */
@@ -999,68 +1090,50 @@ static bool brl_unlock_posix(struct messaging_context *msg_ctx,
                        continue;
                }
 
-               /* Work out overlaps. */
-               tmp_count = brlock_posix_split_merge(&tmp_lock[0], &locks[i], plock, &lock_was_added);
-
-               if (tmp_count == 1) {
-                       /* Ether the locks didn't overlap, or the unlock completely
-                          overlapped this lock. If it didn't overlap, then there's
-                          no change in the locks. */
-                       if (tmp_lock[0].lock_type != UNLOCK_LOCK) {
-                               SMB_ASSERT(tmp_lock[0].lock_type == locks[i].lock_type);
-                               /* No change in this lock. */
-                               memcpy(&tp[count], &tmp_lock[0], sizeof(struct lock_struct));
-                               count++;
-                               posix_count++;
-                       } else {
-                               SMB_ASSERT(tmp_lock[0].lock_type == UNLOCK_LOCK);
-                               overlap_found = True;
-                       }
-                       continue;
-               } else if (tmp_count == 2) {
-                       /* The unlock overlapped an existing lock. Copy the truncated
-                          lock into the lock array. */
-                       if (tmp_lock[0].lock_type != UNLOCK_LOCK) {
-                               SMB_ASSERT(tmp_lock[0].lock_type == locks[i].lock_type);
-                               SMB_ASSERT(tmp_lock[1].lock_type == UNLOCK_LOCK);
-                               memcpy(&tp[count], &tmp_lock[0], sizeof(struct lock_struct));
-                               if (tmp_lock[0].size != locks[i].size) {
-                                       overlap_found = True;
-                               }
-                       } else {
-                               SMB_ASSERT(tmp_lock[0].lock_type == UNLOCK_LOCK);
-                               SMB_ASSERT(tmp_lock[1].lock_type == locks[i].lock_type);
-                               memcpy(&tp[count], &tmp_lock[1], sizeof(struct lock_struct));
-                               if (tmp_lock[1].start != locks[i].start) {
-                                       overlap_found = True;
-                               }
+               if (lock->lock_flav == WINDOWS_LOCK) {
+                       /* Do any Windows flavour locks conflict ? */
+                       if (brl_conflict(lock, plock)) {
+                               SAFE_FREE(tp);
+                               return false;
                        }
+                       /* Just copy the Windows lock into the new array. */
+                       memcpy(&tp[count], lock, sizeof(struct lock_struct));
                        count++;
-                       posix_count++;
                        continue;
-               } else {
-                       /* tmp_count == 3 - (we split a lock range in two). */
-                       SMB_ASSERT(tmp_lock[0].lock_type == locks[i].lock_type);
-                       SMB_ASSERT(tmp_lock[1].lock_type == UNLOCK_LOCK);
-                       SMB_ASSERT(tmp_lock[2].lock_type == locks[i].lock_type);
+               }
+
+               /* Work out overlaps. */
+               tmp_count = brlock_posix_split_merge(&tp[count], lock, plock);
+
+               if (tmp_count == 0) {
+                       /* plock overlapped the existing lock completely,
+                          or replaced it. Don't copy the existing lock. */
+                       overlap_found = true;
+               } else if (tmp_count == 1) {
+                       /* Either no overlap, (simple copy of existing lock) or
+                        * an overlap of an existing lock. */
+                       /* If the lock changed size, we had an overlap. */
+                       if (tp[count].size != lock->size) {
+                               overlap_found = true;
+                       }
+                       count += tmp_count;
+               } else if (tmp_count == 2) {
+                       /* We split a lock range in two. */
+                       overlap_found = true;
+                       count += tmp_count;
 
-                       memcpy(&tp[count], &tmp_lock[0], sizeof(struct lock_struct));
-                       count++;
-                       posix_count++;
-                       memcpy(&tp[count], &tmp_lock[2], sizeof(struct lock_struct));
-                       count++;
-                       posix_count++;
-                       overlap_found = True;
                        /* Optimisation... */
                        /* We know we're finished here as we can't overlap any
                           more POSIX locks. Copy the rest of the lock array. */
+
                        if (i < br_lck->num_locks - 1) {
-                               memcpy(&tp[count], &locks[i+1], 
+                               memcpy(&tp[count], &locks[i+1],
                                        sizeof(*locks)*((br_lck->num_locks-1) - i));
                                count += ((br_lck->num_locks-1) - i);
                        }
                        break;
                }
+
        }
 
        if (!overlap_found) {
@@ -1093,10 +1166,8 @@ static bool brl_unlock_posix(struct messaging_context *msg_ctx,
                tp = NULL;
        }
 
-       if (posix_count == 0) {
-               contend_level2_oplocks_end(br_lck->fsp,
-                                          LEVEL2_CONTEND_POSIX_BRL);
-       }
+       contend_level2_oplocks_end(br_lck->fsp,
+                                  LEVEL2_CONTEND_POSIX_BRL);
 
        br_lck->num_locks = count;
        SAFE_FREE(br_lck->lock_data);

diff --git a/source3/lua-5.1.4/COPYRIGHT b/source3/lua-5.1.4/COPYRIGHT
deleted file mode 100644 (file)
index 3a53e74..0000000
--- a/source3/lua-5.1.4/COPYRIGHT
+++ /dev/null
@@ -1,34 +0,0 @@
-Lua License
------------
-
-Lua is licensed under the terms of the MIT license reproduced below.
-This means that Lua is free software and can be used for both academic
-and commercial purposes at absolutely no cost.
-
-For details and rationale, see http://www.lua.org/license.html .
-
-===============================================================================
-
-Copyright (C) 1994-2008 Lua.org, PUC-Rio.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-===============================================================================
-
-(end of COPYRIGHT)

diff --git a/source3/lua-5.1.4/HISTORY b/source3/lua-5.1.4/HISTORY
deleted file mode 100644 (file)
index ce0c95b..0000000
--- a/source3/lua-5.1.4/HISTORY
+++ /dev/null
@@ -1,183 +0,0 @@
-HISTORY for Lua 5.1
-
-* Changes from version 5.0 to 5.1
-  -------------------------------
-  Language:
-  + new module system.
-  + new semantics for control variables of fors.
-  + new semantics for setn/getn.
-  + new syntax/semantics for varargs.
-  + new long strings and comments.
-  + new `mod' operator (`%')
-  + new length operator #t
-  + metatables for all types
-  API:
-  + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer.
-  + user supplies memory allocator (lua_open becomes lua_newstate).
-  + luaopen_* functions must be called through Lua.
-  Implementation:
-  + new configuration scheme via luaconf.h.
-  + incremental garbage collection.
-  + better handling of end-of-line in the lexer.
-  + fully reentrant parser (new Lua function `load')
-  + better support for 64-bit machines.
-  + native loadlib support for Mac OS X.
-  + standard distribution in only one library (lualib.a merged into lua.a)
-
-* Changes from version 4.0 to 5.0
-  -------------------------------
-  Language:
-  + lexical scoping.
-  + Lua coroutines.
-  + standard libraries now packaged in tables.
-  + tags replaced by metatables and tag methods replaced by metamethods,
-    stored in metatables.
-  + proper tail calls.
-  + each function can have its own global table, which can be shared.
-  + new __newindex metamethod, called when we insert a new key into a table.
-  + new block comments: --[[ ... ]].
-  + new generic for.
-  + new weak tables.
-  + new boolean type.
-  + new syntax "local function".
-  + (f()) returns the first value returned by f.
-  + {f()} fills a table with all values returned by f.
-  + \n ignored in [[\n .
-  + fixed and-or priorities.
-  + more general syntax for function definition (e.g. function a.x.y:f()...end).
-  + more general syntax for function calls (e.g. (print or write)(9)).
-  + new functions (time/date, tmpfile, unpack, require, load*, etc.).
-  API:
-  + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer.
-  + introduced lightweight userdata, a simple "void*" without a metatable.
-  + new error handling protocol: the core no longer prints error messages;
-    all errors are reported to the caller on the stack.
-  + new lua_atpanic for host cleanup.
-  + new, signal-safe, hook scheme.
-  Implementation:
-  + new license: MIT.
-  + new, faster, register-based virtual machine.
-  + support for external multithreading and coroutines.
-  + new and consistent error message format.
-  + the core no longer needs "stdio.h" for anything (except for a single
-    use of sprintf to convert numbers to strings).
-  + lua.c now runs the environment variable LUA_INIT, if present. It can
-    be "@filename", to run a file, or the chunk itself.
-  + support for user extensions in lua.c.
-    sample implementation given for command line editing.
-  + new dynamic loading library, active by default on several platforms.
-  + safe garbage-collector metamethods.
-  + precompiled bytecodes checked for integrity (secure binary dostring).
-  + strings are fully aligned.
-  + position capture in string.find.
-  + read('*l') can read lines with embedded zeros.
-
-* Changes from version 3.2 to 4.0
-  -------------------------------
-  Language:
-  + new "break" and "for" statements (both numerical and for tables).
-  + uniform treatment of globals: globals are now stored in a Lua table.
-  + improved error messages.
-  + no more '$debug': full speed *and* full debug information.
-  + new read form: read(N) for next N bytes.
-  + general read patterns now deprecated.
-    (still available with -DCOMPAT_READPATTERNS.)
-  + all return values are passed as arguments for the last function
-    (old semantics still available with -DLUA_COMPAT_ARGRET)
-  + garbage collection tag methods for tables now deprecated.
-  + there is now only one tag method for order.
-  API:
-  + New API: fully re-entrant, simpler, and more efficient.
-  + New debug API.
-  Implementation:
-  + faster than ever: cleaner virtual machine and new hashing algorithm.
-  + non-recursive garbage-collector algorithm.
-  + reduced memory usage for programs with many strings.
-  + improved treatment for memory allocation errors.
-  + improved support for 16-bit machines (we hope).
-  + code now compiles unmodified as both ANSI C and C++.
-  + numbers in bases other than 10 are converted using strtoul.
-  + new -f option in Lua to support #! scripts.
-  + luac can now combine text and binaries.
-
-* Changes from version 3.1 to 3.2
-  -------------------------------
-  + redirected all output in Lua's core to _ERRORMESSAGE and _ALERT.
-  + increased limit on the number of constants and globals per function
-    (from 2^16 to 2^24).
-  + debugging info (lua_debug and hooks) moved into lua_state and new API
-    functions provided to get and set this info.
-  + new debug lib gives full debugging access within Lua.
-  + new table functions "foreachi", "sort", "tinsert", "tremove", "getn".
-  + new io functions "flush", "seek".
-
-* Changes from version 3.0 to 3.1
-  -------------------------------
-  + NEW FEATURE: anonymous functions with closures (via "upvalues").
-  + new syntax:
-    - local variables in chunks.
-    - better scope control with DO block END.
-    - constructors can now be also written: { record-part; list-part }.
-    - more general syntax for function calls and lvalues, e.g.:
-      f(x).y=1
-      o:f(x,y):g(z)
-      f"string" is sugar for f("string")
-  + strings may now contain arbitrary binary data (e.g., embedded zeros).
-  + major code re-organization and clean-up; reduced module interdependecies.
-  + no arbitrary limits on the total number of constants and globals.
-  + support for multiple global contexts.
-  + better syntax error messages.
-  + new traversal functions "foreach" and "foreachvar".
-  + the default for numbers is now double.
-    changing it to use floats or longs is easy.
-  + complete debug information stored in pre-compiled chunks.
-  + sample interpreter now prompts user when run interactively, and also
-    handles control-C interruptions gracefully.
-
-* Changes from version 2.5 to 3.0
-  -------------------------------
-  + NEW CONCEPT: "tag methods".
-    Tag methods replace fallbacks as the meta-mechanism for extending the
-    semantics of Lua. Whereas fallbacks had a global nature, tag methods
-    work on objects having the same tag (e.g., groups of tables).
-    Existing code that uses fallbacks should work without change.
-  + new, general syntax for constructors {[exp] = exp, ... }.
-  + support for handling variable number of arguments in functions (varargs).
-  + support for conditional compilation ($if ... $else ... $end).
-  + cleaner semantics in API simplifies host code.
-  + better support for writing libraries (auxlib.h).
-  + better type checking and error messages in the standard library.
-  + luac can now also undump.
-
-* Changes from version 2.4 to 2.5
-  -------------------------------
-  + io and string libraries are now based on pattern matching;
-    the old libraries are still available for compatibility
-  + dofile and dostring can now return values (via return statement)
-  + better support for 16- and 64-bit machines
-  + expanded documentation, with more examples
-
-* Changes from version 2.2 to 2.4
-  -------------------------------
-  + external compiler creates portable binary files that can be loaded faster
-  + interface for debugging and profiling
-  + new "getglobal" fallback
-  + new functions for handling references to Lua objects
-  + new functions in standard lib
-  + only one copy of each string is stored
-  + expanded documentation, with more examples
-
-* Changes from version 2.1 to 2.2
-  -------------------------------
-  + functions now may be declared with any "lvalue" as a name
-  + garbage collection of functions
-  + support for pipes
-
-* Changes from version 1.1 to 2.1
-  -------------------------------
-  + object-oriented support
-  + fallbacks
-  + simplified syntax for tables
-  + many internal improvements
-
-(end of HISTORY)

diff --git a/source3/lua-5.1.4/INSTALL b/source3/lua-5.1.4/INSTALL
deleted file mode 100644 (file)
index 17eb8ae..0000000
--- a/source3/lua-5.1.4/INSTALL
+++ /dev/null
@@ -1,99 +0,0 @@
-INSTALL for Lua 5.1
-
-* Building Lua
-  ------------
-  Lua is built in the src directory, but the build process can be
-  controlled from the top-level Makefile.
-
-  Building Lua on Unix systems should be very easy. First do "make" and
-  see if your platform is listed. If so, just do "make xxx", where xxx
-  is your platform name. The platforms currently supported are:
-    aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-  If your platform is not listed, try the closest one or posix, generic,
-  ansi, in this order.
-
-  See below for customization instructions and for instructions on how
-  to build with other Windows compilers.
-
-  If you want to check that Lua has been built correctly, do "make test"
-  after building Lua. Also, have a look at the example programs in test.
-
-* Installing Lua
-  --------------
-  Once you have built Lua, you may want to install it in an official
-  place in your system. In this case, do "make install". The official
-  place and the way to install files are defined in Makefile. You must
-  have the right permissions to install files.
-
-  If you want to build and install Lua in one step, do "make xxx install",
-  where xxx is your platform name.
-
-  If you want to install Lua locally, then do "make local". This will
-  create directories bin, include, lib, man, and install Lua there as
-  follows:
-
-    bin:       lua luac
-    include:   lua.h luaconf.h lualib.h lauxlib.h lua.hpp
-    lib:       liblua.a
-    man/man1:  lua.1 luac.1
-
-  These are the only directories you need for development.
-
-  There are man pages for lua and luac, in both nroff and html, and a
-  reference manual in html in doc, some sample code in test, and some
-  useful stuff in etc. You don't need these directories for development.
-
-  If you want to install Lua locally, but in some other directory, do
-  "make install INSTALL_TOP=xxx", where xxx is your chosen directory.
-
-  See below for instructions for Windows and other systems.
-
-* Customization
-  -------------
-  Three things can be customized by editing a file:
-    - Where and how to install Lua -- edit Makefile.
-    - How to build Lua -- edit src/Makefile.
-    - Lua features -- edit src/luaconf.h.
-
-  You don't actually need to edit the Makefiles because you may set the
-  relevant variables when invoking make.
-
-  On the other hand, if you need to select some Lua features, you'll need
-  to edit src/luaconf.h. The edited file will be the one installed, and
-  it will be used by any Lua clients that you build, to ensure consistency.
-
-  We strongly recommend that you enable dynamic loading. This is done
-  automatically for all platforms listed above that have this feature
-  (and also Windows). See src/luaconf.h and also src/Makefile.
-
-* Building Lua on Windows and other systems
-  -----------------------------------------
-  If you're not using the usual Unix tools, then the instructions for
-  building Lua depend on the compiler you use. You'll need to create
-  projects (or whatever your compiler uses) for building the library,
-  the interpreter, and the compiler, as follows:
-
-  library:     lapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c
-               lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c
-               ltable.c ltm.c lundump.c lvm.c lzio.c
-               lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c
-               ltablib.c lstrlib.c loadlib.c linit.c
-
-  interpreter: library, lua.c
-
-  compiler:    library, luac.c print.c
-
-  If you use Visual Studio .NET, you can use etc/luavs.bat in its
-  "Command Prompt".
-
-  If all you want is to build the Lua interpreter, you may put all .c files
-  in a single project, except for luac.c and print.c. Or just use etc/all.c.
-
-  To use Lua as a library in your own programs, you'll need to know how to
-  create and use libraries with your compiler.
-
-  As mentioned above, you may edit luaconf.h to select some features before
-  building Lua.
-
-(end of INSTALL)

diff --git a/source3/lua-5.1.4/Makefile b/source3/lua-5.1.4/Makefile
deleted file mode 100644 (file)
index 6e78f66..0000000
--- a/source3/lua-5.1.4/Makefile
+++ /dev/null
@@ -1,128 +0,0 @@
-# makefile for installing Lua
-# see INSTALL for installation instructions
-# see src/Makefile and src/luaconf.h for further customization
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-# Where to install. The installation starts in the src and doc directories,
-# so take care if INSTALL_TOP is not an absolute path.
-INSTALL_TOP= /usr/local
-INSTALL_BIN= $(INSTALL_TOP)/bin
-INSTALL_INC= $(INSTALL_TOP)/include
-INSTALL_LIB= $(INSTALL_TOP)/lib
-INSTALL_MAN= $(INSTALL_TOP)/man/man1
-#
-# You probably want to make INSTALL_LMOD and INSTALL_CMOD consistent with
-# LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h (and also with etc/lua.pc).
-INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V
-INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V
-
-# How to install. If your install program does not support "-p", then you
-# may have to run ranlib on the installed liblua.a (do "make ranlib").
-INSTALL= install -p
-INSTALL_EXEC= $(INSTALL) -m 0755
-INSTALL_DATA= $(INSTALL) -m 0644
-#
-# If you don't have install you can use cp instead.
-# INSTALL= cp -p
-# INSTALL_EXEC= $(INSTALL)
-# INSTALL_DATA= $(INSTALL)
-
-# Utilities.
-MKDIR= mkdir -p
-RANLIB= ranlib
-
-# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
-
-# Convenience platforms targets.
-PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-# What to install.
-TO_BIN= lua luac
-TO_INC= lua.h luaconf.h lualib.h lauxlib.h ../etc/lua.hpp
-TO_LIB= liblua.a
-TO_MAN= lua.1 luac.1
-
-# Lua version and release.
-V= 5.1
-R= 5.1.4
-
-all:   $(PLAT)
-
-$(PLATS) clean:
-       cd src && $(MAKE) $@
-
-test:  dummy
-       src/lua test/hello.lua
-
-install: dummy
-       cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)
-       cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
-       cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
-       cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
-       cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
-
-ranlib:
-       cd src && cd $(INSTALL_LIB) && $(RANLIB) $(TO_LIB)
-
-local:
-       $(MAKE) install INSTALL_TOP=..
-
-none:
-       @echo "Please do"
-       @echo "   make PLATFORM"
-       @echo "where PLATFORM is one of these:"
-       @echo "   $(PLATS)"
-       @echo "See INSTALL for complete instructions."
-
-# make may get confused with test/ and INSTALL in a case-insensitive OS
-dummy:
-
-# echo config parameters
-echo:
-       @echo ""
-       @echo "These are the parameters currently set in src/Makefile to build Lua $R:"
-       @echo ""
-       @cd src && $(MAKE) -s echo
-       @echo ""
-       @echo "These are the parameters currently set in Makefile to install Lua $R:"
-       @echo ""
-       @echo "PLAT = $(PLAT)"
-       @echo "INSTALL_TOP = $(INSTALL_TOP)"
-       @echo "INSTALL_BIN = $(INSTALL_BIN)"
-       @echo "INSTALL_INC = $(INSTALL_INC)"
-       @echo "INSTALL_LIB = $(INSTALL_LIB)"
-       @echo "INSTALL_MAN = $(INSTALL_MAN)"
-       @echo "INSTALL_LMOD = $(INSTALL_LMOD)"
-       @echo "INSTALL_CMOD = $(INSTALL_CMOD)"
-       @echo "INSTALL_EXEC = $(INSTALL_EXEC)"
-       @echo "INSTALL_DATA = $(INSTALL_DATA)"
-       @echo ""
-       @echo "See also src/luaconf.h ."
-       @echo ""
-
-# echo private config parameters
-pecho:
-       @echo "V = $(V)"
-       @echo "R = $(R)"
-       @echo "TO_BIN = $(TO_BIN)"
-       @echo "TO_INC = $(TO_INC)"
-       @echo "TO_LIB = $(TO_LIB)"
-       @echo "TO_MAN = $(TO_MAN)"
-
-# echo config parameters as Lua code
-# uncomment the last sed expression if you want nil instead of empty strings
-lecho:
-       @echo "-- installation parameters for Lua $R"
-       @echo "VERSION = '$V'"
-       @echo "RELEASE = '$R'"
-       @$(MAKE) echo | grep = | sed -e 's/= /= "/' -e 's/$$/"/' #-e 's/""/nil/'
-       @echo "-- EOF"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) clean test install local none dummy echo pecho lecho
-
-# (end of Makefile)

diff --git a/source3/lua-5.1.4/README b/source3/lua-5.1.4/README
deleted file mode 100644 (file)
index 11b4dff..0000000
--- a/source3/lua-5.1.4/README
+++ /dev/null
@@ -1,37 +0,0 @@
-README for Lua 5.1
-
-See INSTALL for installation instructions.
-See HISTORY for a summary of changes since the last released version.
-
-* What is Lua?
-  ------------
-  Lua is a powerful, light-weight programming language designed for extending
-  applications. Lua is also frequently used as a general-purpose, stand-alone
-  language. Lua is free software.
-
-  For complete information, visit Lua's web site at http://www.lua.org/ .
-  For an executive summary, see http://www.lua.org/about.html .
-
-  Lua has been used in many different projects around the world.
-  For a short list, see http://www.lua.org/uses.html .
-
-* Availability
-  ------------
-  Lua is freely available for both academic and commercial purposes.
-  See COPYRIGHT and http://www.lua.org/license.html for details.
-  Lua can be downloaded at http://www.lua.org/download.html .
-
-* Installation
-  ------------
-  Lua is implemented in pure ANSI C, and compiles unmodified in all known
-  platforms that have an ANSI C compiler. In most Unix-like platforms, simply
-  do "make" with a suitable target. See INSTALL for detailed instructions.
-
-* Origin
-  ------
-  Lua is developed at Lua.org, a laboratory of the Department of Computer
-  Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro
-  in Brazil).
-  For more information about the authors, see http://www.lua.org/authors.html .
-
-(end of README)

diff --git a/source3/lua-5.1.4/doc/amazon.gif b/source3/lua-5.1.4/doc/amazon.gif
deleted file mode 100644 (file)
index f2586d5..0000000
Binary files a/source3/lua-5.1.4/doc/amazon.gif and /dev/null differ

diff --git a/source3/lua-5.1.4/doc/contents.html b/source3/lua-5.1.4/doc/contents.html
deleted file mode 100644 (file)
index 422bbbf..0000000
--- a/source3/lua-5.1.4/doc/contents.html
+++ /dev/null
@@ -1,499 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<HTML>
-<HEAD>
-<TITLE>Lua 5.1 Reference Manual - contents</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-<STYLE TYPE="text/css">
-ul {
-       list-style-type: none ;
-       list-style-position: outside ;
-}
-</STYLE>
-</HEAD>
-
-<BODY>
-
-<HR>
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="" BORDER=0></A>
-Lua 5.1 Reference Manual
-</H1>
-
-This is an online version of
-<BLOCKQUOTE>
-<A HREF="http://www.amazon.com/exec/obidos/ASIN/8590379833/lua-indexmanual-20">
-<IMG SRC="cover.png" ALT="" TITLE="buy from Amazon" BORDER=1 ALIGN="left" HSPACE=12>
-</A>
-<B>Lua 5.1 Reference Manual</B>
-<BR>by R. Ierusalimschy, L. H. de Figueiredo, W. Celes
-<BR>Lua.org, August 2006
-<BR>ISBN 85-903798-3-3
-<BR><A HREF="http://www.amazon.com/exec/obidos/ASIN/8590379833/lua-indexmanual-20">
-<IMG SRC="amazon.gif" ALT="[Buy from Amazon]" BORDER=0></A>
-<BR CLEAR="all">
-</BLOCKQUOTE>
-<P>
-
-Buy a copy of this book and
-<A HREF="http://www.lua.org/donations.html">help to support</A>
-the Lua project.
-<P>
-
-The reference manual is the official definition of the Lua language.
-For a complete introduction to Lua programming, see the book
-<A HREF="http://www.lua.org/docs.html#books">Programming in Lua</A>.
-<P>
-
-<A HREF="manual.html">start</A>
-&middot;
-<A HREF="#contents">contents</A>
-&middot;
-<A HREF="#index">index</A>
-&middot;
-<A HREF="http://www.lua.org/manual/5.1/pt/">português</A>
-&middot;
-<A HREF="http://www.lua.org/manual/5.1/es/">español</A>
-<HR>
-<SMALL>
-Copyright &copy; 2006-2008 Lua.org, PUC-Rio.
-Freely available under the terms of the
-<a href="http://www.lua.org/license.html#5">Lua license</a>.
-</SMALL>
-<P>
-
-<H2><A NAME="contents">Contents</A></H2>
-<UL style="padding: 0">
-<LI><A HREF="manual.html">1 - Introduction</A>
-<P>
-<LI><A HREF="manual.html#2">2 - The Language</A>
-<UL>
-<LI><A HREF="manual.html#2.1">2.1 - Lexical Conventions</A>
-<LI><A HREF="manual.html#2.2">2.2 - Values and Types</A>
-<UL>
-<LI><A HREF="manual.html#2.2.1">2.2.1 - Coercion</A>
-</UL>
-<LI><A HREF="manual.html#2.3">2.3 - Variables</A>
-<LI><A HREF="manual.html#2.4">2.4 - Statements</A>
-<UL>
-<LI><A HREF="manual.html#2.4.1">2.4.1 - Chunks</A>
-<LI><A HREF="manual.html#2.4.2">2.4.2 - Blocks</A>
-<LI><A HREF="manual.html#2.4.3">2.4.3 - Assignment</A>
-<LI><A HREF="manual.html#2.4.4">2.4.4 - Control Structures</A>
-<LI><A HREF="manual.html#2.4.5">2.4.5 - For Statement</A>
-<LI><A HREF="manual.html#2.4.6">2.4.6 - Function Calls as Statements</A>
-<LI><A HREF="manual.html#2.4.7">2.4.7 - Local Declarations</A>
-</UL>
-<LI><A HREF="manual.html#2.5">2.5 - Expressions</A>
-<UL>
-<LI><A HREF="manual.html#2.5.1">2.5.1 - Arithmetic Operators</A>
-<LI><A HREF="manual.html#2.5.2">2.5.2 - Relational Operators</A>
-<LI><A HREF="manual.html#2.5.3">2.5.3 - Logical Operators</A>
-<LI><A HREF="manual.html#2.5.4">2.5.4 - Concatenation</A>
-<LI><A HREF="manual.html#2.5.5">2.5.5 - The Length Operator</A>
-<LI><A HREF="manual.html#2.5.6">2.5.6 - Precedence</A>
-<LI><A HREF="manual.html#2.5.7">2.5.7 - Table Constructors</A>
-<LI><A HREF="manual.html#2.5.8">2.5.8 - Function Calls</A>
-<LI><A HREF="manual.html#2.5.9">2.5.9 - Function Definitions</A>
-</UL>
-<LI><A HREF="manual.html#2.6">2.6 - Visibility Rules</A>
-<LI><A HREF="manual.html#2.7">2.7 - Error Handling</A>
-<LI><A HREF="manual.html#2.8">2.8 - Metatables</A>
-<LI><A HREF="manual.html#2.9">2.9 - Environments</A>
-<LI><A HREF="manual.html#2.10">2.10 - Garbage Collection</A>
-<UL>
-<LI><A HREF="manual.html#2.10.1">2.10.1 - Garbage-Collection Metamethods</A>
-<LI><A HREF="manual.html#2.10.2">2.10.2 - Weak Tables</A>
-</UL>
-<LI><A HREF="manual.html#2.11">2.11 - Coroutines</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#3">3 - The Application Program Interface</A>
-<UL>
-<LI><A HREF="manual.html#3.1">3.1 - The Stack</A>
-<LI><A HREF="manual.html#3.2">3.2 - Stack Size</A>
-<LI><A HREF="manual.html#3.3">3.3 - Pseudo-Indices</A>
-<LI><A HREF="manual.html#3.4">3.4 - C Closures</A>
-<LI><A HREF="manual.html#3.5">3.5 - Registry</A>
-<LI><A HREF="manual.html#3.6">3.6 - Error Handling in C</A>
-<LI><A HREF="manual.html#3.7">3.7 - Functions and Types</A>
-<LI><A HREF="manual.html#3.8">3.8 - The Debug Interface</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#4">4 - The Auxiliary Library</A>
-<UL>
-<LI><A HREF="manual.html#4.1">4.1 - Functions and Types</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#5">5 - Standard Libraries</A>
-<UL>
-<LI><A HREF="manual.html#5.1">5.1 - Basic Functions</A>
-<LI><A HREF="manual.html#5.2">5.2 - Coroutine Manipulation</A>
-<LI><A HREF="manual.html#5.3">5.3 - Modules</A>
-<LI><A HREF="manual.html#5.4">5.4 - String Manipulation</A>
-<UL>
-<LI><A HREF="manual.html#5.4.1">5.4.1 - Patterns</A>
-</UL>
-<LI><A HREF="manual.html#5.5">5.5 - Table Manipulation</A>
-<LI><A HREF="manual.html#5.6">5.6 - Mathematical Functions</A>
-<LI><A HREF="manual.html#5.7">5.7 - Input and Output Facilities</A>
-<LI><A HREF="manual.html#5.8">5.8 - Operating System Facilities</A>
-<LI><A HREF="manual.html#5.9">5.9 - The Debug Library</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#6">6 - Lua Stand-alone</A>
-<P>
-<LI><A HREF="manual.html#7">7 - Incompatibilities with the Previous Version</A>
-<UL>
-<LI><A HREF="manual.html#7.1">7.1 - Changes in the Language</A>
-<LI><A HREF="manual.html#7.2">7.2 - Changes in the Libraries</A>
-<LI><A HREF="manual.html#7.3">7.3 - Changes in the API</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#8">8 - The Complete Syntax of Lua</A>
-</UL>
-
-<H2><A NAME="index">Index</A></H2>
-<TABLE WIDTH="100%">
-<TR VALIGN="top">
-<TD>
-<H3><A NAME="functions">Lua functions</A></H3>
-<A HREF="manual.html#pdf-_G">_G</A><BR>
-<A HREF="manual.html#pdf-_VERSION">_VERSION</A><BR>
-<A HREF="manual.html#pdf-assert">assert</A><BR>
-<A HREF="manual.html#pdf-collectgarbage">collectgarbage</A><BR>
-<A HREF="manual.html#pdf-dofile">dofile</A><BR>
-<A HREF="manual.html#pdf-error">error</A><BR>
-<A HREF="manual.html#pdf-getfenv">getfenv</A><BR>
-<A HREF="manual.html#pdf-getmetatable">getmetatable</A><BR>
-<A HREF="manual.html#pdf-ipairs">ipairs</A><BR>
-<A HREF="manual.html#pdf-load">load</A><BR>
-<A HREF="manual.html#pdf-loadfile">loadfile</A><BR>
-<A HREF="manual.html#pdf-loadstring">loadstring</A><BR>
-<A HREF="manual.html#pdf-module">module</A><BR>
-<A HREF="manual.html#pdf-next">next</A><BR>
-<A HREF="manual.html#pdf-pairs">pairs</A><BR>
-<A HREF="manual.html#pdf-pcall">pcall</A><BR>
-<A HREF="manual.html#pdf-print">print</A><BR>
-<A HREF="manual.html#pdf-rawequal">rawequal</A><BR>
-<A HREF="manual.html#pdf-rawget">rawget</A><BR>
-<A HREF="manual.html#pdf-rawset">rawset</A><BR>
-<A HREF="manual.html#pdf-require">require</A><BR>
-<A HREF="manual.html#pdf-select">select</A><BR>
-<A HREF="manual.html#pdf-setfenv">setfenv</A><BR>
-<A HREF="manual.html#pdf-setmetatable">setmetatable</A><BR>
-<A HREF="manual.html#pdf-tonumber">tonumber</A><BR>
-<A HREF="manual.html#pdf-tostring">tostring</A><BR>
-<A HREF="manual.html#pdf-type">type</A><BR>
-<A HREF="manual.html#pdf-unpack">unpack</A><BR>
-<A HREF="manual.html#pdf-xpcall">xpcall</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-coroutine.create">coroutine.create</A><BR>
-<A HREF="manual.html#pdf-coroutine.resume">coroutine.resume</A><BR>
-<A HREF="manual.html#pdf-coroutine.running">coroutine.running</A><BR>
-<A HREF="manual.html#pdf-coroutine.status">coroutine.status</A><BR>
-<A HREF="manual.html#pdf-coroutine.wrap">coroutine.wrap</A><BR>
-<A HREF="manual.html#pdf-coroutine.yield">coroutine.yield</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-debug.debug">debug.debug</A><BR>
-<A HREF="manual.html#pdf-debug.getfenv">debug.getfenv</A><BR>
-<A HREF="manual.html#pdf-debug.gethook">debug.gethook</A><BR>
-<A HREF="manual.html#pdf-debug.getinfo">debug.getinfo</A><BR>
-<A HREF="manual.html#pdf-debug.getlocal">debug.getlocal</A><BR>
-<A HREF="manual.html#pdf-debug.getmetatable">debug.getmetatable</A><BR>
-<A HREF="manual.html#pdf-debug.getregistry">debug.getregistry</A><BR>
-<A HREF="manual.html#pdf-debug.getupvalue">debug.getupvalue</A><BR>
-<A HREF="manual.html#pdf-debug.setfenv">debug.setfenv</A><BR>
-<A HREF="manual.html#pdf-debug.sethook">debug.sethook</A><BR>
-<A HREF="manual.html#pdf-debug.setlocal">debug.setlocal</A><BR>
-<A HREF="manual.html#pdf-debug.setmetatable">debug.setmetatable</A><BR>
-<A HREF="manual.html#pdf-debug.setupvalue">debug.setupvalue</A><BR>
-<A HREF="manual.html#pdf-debug.traceback">debug.traceback</A><BR>
-
-</TD>
-<TD>
-<H3>&nbsp;</H3>
-<A HREF="manual.html#pdf-file:close">file:close</A><BR>
-<A HREF="manual.html#pdf-file:flush">file:flush</A><BR>
-<A HREF="manual.html#pdf-file:lines">file:lines</A><BR>
-<A HREF="manual.html#pdf-file:read">file:read</A><BR>
-<A HREF="manual.html#pdf-file:seek">file:seek</A><BR>
-<A HREF="manual.html#pdf-file:setvbuf">file:setvbuf</A><BR>
-<A HREF="manual.html#pdf-file:write">file:write</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-io.close">io.close</A><BR>
-<A HREF="manual.html#pdf-io.flush">io.flush</A><BR>
-<A HREF="manual.html#pdf-io.input">io.input</A><BR>
-<A HREF="manual.html#pdf-io.lines">io.lines</A><BR>
-<A HREF="manual.html#pdf-io.open">io.open</A><BR>
-<A HREF="manual.html#pdf-io.output">io.output</A><BR>
-<A HREF="manual.html#pdf-io.popen">io.popen</A><BR>
-<A HREF="manual.html#pdf-io.read">io.read</A><BR>
-<A HREF="manual.html#pdf-io.stderr">io.stderr</A><BR>
-<A HREF="manual.html#pdf-io.stdin">io.stdin</A><BR>
-<A HREF="manual.html#pdf-io.stdout">io.stdout</A><BR>
-<A HREF="manual.html#pdf-io.tmpfile">io.tmpfile</A><BR>
-<A HREF="manual.html#pdf-io.type">io.type</A><BR>
-<A HREF="manual.html#pdf-io.write">io.write</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-math.abs">math.abs</A><BR>
-<A HREF="manual.html#pdf-math.acos">math.acos</A><BR>
-<A HREF="manual.html#pdf-math.asin">math.asin</A><BR>
-<A HREF="manual.html#pdf-math.atan">math.atan</A><BR>
-<A HREF="manual.html#pdf-math.atan2">math.atan2</A><BR>
-<A HREF="manual.html#pdf-math.ceil">math.ceil</A><BR>
-<A HREF="manual.html#pdf-math.cos">math.cos</A><BR>
-<A HREF="manual.html#pdf-math.cosh">math.cosh</A><BR>
-<A HREF="manual.html#pdf-math.deg">math.deg</A><BR>
-<A HREF="manual.html#pdf-math.exp">math.exp</A><BR>
-<A HREF="manual.html#pdf-math.floor">math.floor</A><BR>
-<A HREF="manual.html#pdf-math.fmod">math.fmod</A><BR>
-<A HREF="manual.html#pdf-math.frexp">math.frexp</A><BR>
-<A HREF="manual.html#pdf-math.huge">math.huge</A><BR>
-<A HREF="manual.html#pdf-math.ldexp">math.ldexp</A><BR>
-<A HREF="manual.html#pdf-math.log">math.log</A><BR>
-<A HREF="manual.html#pdf-math.log10">math.log10</A><BR>
-<A HREF="manual.html#pdf-math.max">math.max</A><BR>
-<A HREF="manual.html#pdf-math.min">math.min</A><BR>
-<A HREF="manual.html#pdf-math.modf">math.modf</A><BR>
-<A HREF="manual.html#pdf-math.pi">math.pi</A><BR>
-<A HREF="manual.html#pdf-math.pow">math.pow</A><BR>
-<A HREF="manual.html#pdf-math.rad">math.rad</A><BR>
-<A HREF="manual.html#pdf-math.random">math.random</A><BR>
-<A HREF="manual.html#pdf-math.randomseed">math.randomseed</A><BR>
-<A HREF="manual.html#pdf-math.sin">math.sin</A><BR>
-<A HREF="manual.html#pdf-math.sinh">math.sinh</A><BR>
-<A HREF="manual.html#pdf-math.sqrt">math.sqrt</A><BR>
-<A HREF="manual.html#pdf-math.tan">math.tan</A><BR>
-<A HREF="manual.html#pdf-math.tanh">math.tanh</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-os.clock">os.clock</A><BR>
-<A HREF="manual.html#pdf-os.date">os.date</A><BR>
-<A HREF="manual.html#pdf-os.difftime">os.difftime</A><BR>
-<A HREF="manual.html#pdf-os.execute">os.execute</A><BR>
-<A HREF="manual.html#pdf-os.exit">os.exit</A><BR>
-<A HREF="manual.html#pdf-os.getenv">os.getenv</A><BR>
-<A HREF="manual.html#pdf-os.remove">os.remove</A><BR>
-<A HREF="manual.html#pdf-os.rename">os.rename</A><BR>
-<A HREF="manual.html#pdf-os.setlocale">os.setlocale</A><BR>
-<A HREF="manual.html#pdf-os.time">os.time</A><BR>
-<A HREF="manual.html#pdf-os.tmpname">os.tmpname</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-package.cpath">package.cpath</A><BR>
-<A HREF="manual.html#pdf-package.loaded">package.loaded</A><BR>
-<A HREF="manual.html#pdf-package.loaders">package.loaders</A><BR>
-<A HREF="manual.html#pdf-package.loadlib">package.loadlib</A><BR>
-<A HREF="manual.html#pdf-package.path">package.path</A><BR>
-<A HREF="manual.html#pdf-package.preload">package.preload</A><BR>
-<A HREF="manual.html#pdf-package.seeall">package.seeall</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-string.byte">string.byte</A><BR>
-<A HREF="manual.html#pdf-string.char">string.char</A><BR>
-<A HREF="manual.html#pdf-string.dump">string.dump</A><BR>
-<A HREF="manual.html#pdf-string.find">string.find</A><BR>
-<A HREF="manual.html#pdf-string.format">string.format</A><BR>
-<A HREF="manual.html#pdf-string.gmatch">string.gmatch</A><BR>
-<A HREF="manual.html#pdf-string.gsub">string.gsub</A><BR>
-<A HREF="manual.html#pdf-string.len">string.len</A><BR>
-<A HREF="manual.html#pdf-string.lower">string.lower</A><BR>
-<A HREF="manual.html#pdf-string.match">string.match</A><BR>
-<A HREF="manual.html#pdf-string.rep">string.rep</A><BR>
-<A HREF="manual.html#pdf-string.reverse">string.reverse</A><BR>
-<A HREF="manual.html#pdf-string.sub">string.sub</A><BR>
-<A HREF="manual.html#pdf-string.upper">string.upper</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-table.concat">table.concat</A><BR>
-<A HREF="manual.html#pdf-table.insert">table.insert</A><BR>
-<A HREF="manual.html#pdf-table.maxn">table.maxn</A><BR>
-<A HREF="manual.html#pdf-table.remove">table.remove</A><BR>
-<A HREF="manual.html#pdf-table.sort">table.sort</A><BR>
-
-</TD>
-<TD>
-<H3>C API</H3>
-<A HREF="manual.html#lua_Alloc">lua_Alloc</A><BR>
-<A HREF="manual.html#lua_CFunction">lua_CFunction</A><BR>
-<A HREF="manual.html#lua_Debug">lua_Debug</A><BR>
-<A HREF="manual.html#lua_Hook">lua_Hook</A><BR>
-<A HREF="manual.html#lua_Integer">lua_Integer</A><BR>
-<A HREF="manual.html#lua_Number">lua_Number</A><BR>
-<A HREF="manual.html#lua_Reader">lua_Reader</A><BR>
-<A HREF="manual.html#lua_State">lua_State</A><BR>
-<A HREF="manual.html#lua_Writer">lua_Writer</A><BR>
-<P>
-
-<A HREF="manual.html#lua_atpanic">lua_atpanic</A><BR>
-<A HREF="manual.html#lua_call">lua_call</A><BR>
-<A HREF="manual.html#lua_checkstack">lua_checkstack</A><BR>
-<A HREF="manual.html#lua_close">lua_close</A><BR>
-<A HREF="manual.html#lua_concat">lua_concat</A><BR>
-<A HREF="manual.html#lua_cpcall">lua_cpcall</A><BR>
-<A HREF="manual.html#lua_createtable">lua_createtable</A><BR>
-<A HREF="manual.html#lua_dump">lua_dump</A><BR>
-<A HREF="manual.html#lua_equal">lua_equal</A><BR>
-<A HREF="manual.html#lua_error">lua_error</A><BR>
-<A HREF="manual.html#lua_gc">lua_gc</A><BR>
-<A HREF="manual.html#lua_getallocf">lua_getallocf</A><BR>
-<A HREF="manual.html#lua_getfenv">lua_getfenv</A><BR>
-<A HREF="manual.html#lua_getfield">lua_getfield</A><BR>
-<A HREF="manual.html#lua_getglobal">lua_getglobal</A><BR>
-<A HREF="manual.html#lua_gethook">lua_gethook</A><BR>
-<A HREF="manual.html#lua_gethookcount">lua_gethookcount</A><BR>
-<A HREF="manual.html#lua_gethookmask">lua_gethookmask</A><BR>
-<A HREF="manual.html#lua_getinfo">lua_getinfo</A><BR>
-<A HREF="manual.html#lua_getlocal">lua_getlocal</A><BR>
-<A HREF="manual.html#lua_getmetatable">lua_getmetatable</A><BR>
-<A HREF="manual.html#lua_getstack">lua_getstack</A><BR>
-<A HREF="manual.html#lua_gettable">lua_gettable</A><BR>
-<A HREF="manual.html#lua_gettop">lua_gettop</A><BR>
-<A HREF="manual.html#lua_getupvalue">lua_getupvalue</A><BR>
-<A HREF="manual.html#lua_insert">lua_insert</A><BR>
-<A HREF="manual.html#lua_isboolean">lua_isboolean</A><BR>
-<A HREF="manual.html#lua_iscfunction">lua_iscfunction</A><BR>
-<A HREF="manual.html#lua_isfunction">lua_isfunction</A><BR>
-<A HREF="manual.html#lua_islightuserdata">lua_islightuserdata</A><BR>
-<A HREF="manual.html#lua_isnil">lua_isnil</A><BR>
-<A HREF="manual.html#lua_isnone">lua_isnone</A><BR>
-<A HREF="manual.html#lua_isnoneornil">lua_isnoneornil</A><BR>
-<A HREF="manual.html#lua_isnumber">lua_isnumber</A><BR>
-<A HREF="manual.html#lua_isstring">lua_isstring</A><BR>
-<A HREF="manual.html#lua_istable">lua_istable</A><BR>
-<A HREF="manual.html#lua_isthread">lua_isthread</A><BR>
-<A HREF="manual.html#lua_isuserdata">lua_isuserdata</A><BR>
-<A HREF="manual.html#lua_lessthan">lua_lessthan</A><BR>
-<A HREF="manual.html#lua_load">lua_load</A><BR>
-<A HREF="manual.html#lua_newstate">lua_newstate</A><BR>
-<A HREF="manual.html#lua_newtable">lua_newtable</A><BR>
-<A HREF="manual.html#lua_newthread">lua_newthread</A><BR>
-<A HREF="manual.html#lua_newuserdata">lua_newuserdata</A><BR>
-<A HREF="manual.html#lua_next">lua_next</A><BR>
-<A HREF="manual.html#lua_objlen">lua_objlen</A><BR>
-<A HREF="manual.html#lua_pcall">lua_pcall</A><BR>
-<A HREF="manual.html#lua_pop">lua_pop</A><BR>
-<A HREF="manual.html#lua_pushboolean">lua_pushboolean</A><BR>
-<A HREF="manual.html#lua_pushcclosure">lua_pushcclosure</A><BR>
-<A HREF="manual.html#lua_pushcfunction">lua_pushcfunction</A><BR>
-<A HREF="manual.html#lua_pushfstring">lua_pushfstring</A><BR>
-<A HREF="manual.html#lua_pushinteger">lua_pushinteger</A><BR>
-<A HREF="manual.html#lua_pushlightuserdata">lua_pushlightuserdata</A><BR>
-<A HREF="manual.html#lua_pushliteral">lua_pushliteral</A><BR>
-<A HREF="manual.html#lua_pushlstring">lua_pushlstring</A><BR>
-<A HREF="manual.html#lua_pushnil">lua_pushnil</A><BR>
-<A HREF="manual.html#lua_pushnumber">lua_pushnumber</A><BR>
-<A HREF="manual.html#lua_pushstring">lua_pushstring</A><BR>
-<A HREF="manual.html#lua_pushthread">lua_pushthread</A><BR>
-<A HREF="manual.html#lua_pushvalue">lua_pushvalue</A><BR>
-<A HREF="manual.html#lua_pushvfstring">lua_pushvfstring</A><BR>
-<A HREF="manual.html#lua_rawequal">lua_rawequal</A><BR>
-<A HREF="manual.html#lua_rawget">lua_rawget</A><BR>
-<A HREF="manual.html#lua_rawgeti">lua_rawgeti</A><BR>
-<A HREF="manual.html#lua_rawset">lua_rawset</A><BR>
-<A HREF="manual.html#lua_rawseti">lua_rawseti</A><BR>
-<A HREF="manual.html#lua_register">lua_register</A><BR>
-<A HREF="manual.html#lua_remove">lua_remove</A><BR>
-<A HREF="manual.html#lua_replace">lua_replace</A><BR>
-<A HREF="manual.html#lua_resume">lua_resume</A><BR>
-<A HREF="manual.html#lua_setallocf">lua_setallocf</A><BR>
-<A HREF="manual.html#lua_setfenv">lua_setfenv</A><BR>
-<A HREF="manual.html#lua_setfield">lua_setfield</A><BR>
-<A HREF="manual.html#lua_setglobal">lua_setglobal</A><BR>
-<A HREF="manual.html#lua_sethook">lua_sethook</A><BR>
-<A HREF="manual.html#lua_setlocal">lua_setlocal</A><BR>
-<A HREF="manual.html#lua_setmetatable">lua_setmetatable</A><BR>
-<A HREF="manual.html#lua_settable">lua_settable</A><BR>
-<A HREF="manual.html#lua_settop">lua_settop</A><BR>
-<A HREF="manual.html#lua_setupvalue">lua_setupvalue</A><BR>
-<A HREF="manual.html#lua_status">lua_status</A><BR>
-<A HREF="manual.html#lua_toboolean">lua_toboolean</A><BR>
-<A HREF="manual.html#lua_tocfunction">lua_tocfunction</A><BR>
-<A HREF="manual.html#lua_tointeger">lua_tointeger</A><BR>
-<A HREF="manual.html#lua_tolstring">lua_tolstring</A><BR>
-<A HREF="manual.html#lua_tonumber">lua_tonumber</A><BR>
-<A HREF="manual.html#lua_topointer">lua_topointer</A><BR>
-<A HREF="manual.html#lua_tostring">lua_tostring</A><BR>
-<A HREF="manual.html#lua_tothread">lua_tothread</A><BR>
-<A HREF="manual.html#lua_touserdata">lua_touserdata</A><BR>
-<A HREF="manual.html#lua_type">lua_type</A><BR>
-<A HREF="manual.html#lua_typename">lua_typename</A><BR>
-<A HREF="manual.html#lua_upvalueindex">lua_upvalueindex</A><BR>
-<A HREF="manual.html#lua_xmove">lua_xmove</A><BR>
-<A HREF="manual.html#lua_yield">lua_yield</A><BR>
-
-</TD>
-<TD>
-<H3>auxiliary library</H3>
-<A HREF="manual.html#luaL_Buffer">luaL_Buffer</A><BR>
-<A HREF="manual.html#luaL_Reg">luaL_Reg</A><BR>
-<P>
-
-<A HREF="manual.html#luaL_addchar">luaL_addchar</A><BR>
-<A HREF="manual.html#luaL_addlstring">luaL_addlstring</A><BR>
-<A HREF="manual.html#luaL_addsize">luaL_addsize</A><BR>
-<A HREF="manual.html#luaL_addstring">luaL_addstring</A><BR>
-<A HREF="manual.html#luaL_addvalue">luaL_addvalue</A><BR>
-<A HREF="manual.html#luaL_argcheck">luaL_argcheck</A><BR>
-<A HREF="manual.html#luaL_argerror">luaL_argerror</A><BR>
-<A HREF="manual.html#luaL_buffinit">luaL_buffinit</A><BR>
-<A HREF="manual.html#luaL_callmeta">luaL_callmeta</A><BR>
-<A HREF="manual.html#luaL_checkany">luaL_checkany</A><BR>
-<A HREF="manual.html#luaL_checkint">luaL_checkint</A><BR>
-<A HREF="manual.html#luaL_checkinteger">luaL_checkinteger</A><BR>
-<A HREF="manual.html#luaL_checklong">luaL_checklong</A><BR>
-<A HREF="manual.html#luaL_checklstring">luaL_checklstring</A><BR>
-<A HREF="manual.html#luaL_checknumber">luaL_checknumber</A><BR>
-<A HREF="manual.html#luaL_checkoption">luaL_checkoption</A><BR>
-<A HREF="manual.html#luaL_checkstack">luaL_checkstack</A><BR>
-<A HREF="manual.html#luaL_checkstring">luaL_checkstring</A><BR>
-<A HREF="manual.html#luaL_checktype">luaL_checktype</A><BR>
-<A HREF="manual.html#luaL_checkudata">luaL_checkudata</A><BR>
-<A HREF="manual.html#luaL_dofile">luaL_dofile</A><BR>
-<A HREF="manual.html#luaL_dostring">luaL_dostring</A><BR>
-<A HREF="manual.html#luaL_error">luaL_error</A><BR>
-<A HREF="manual.html#luaL_getmetafield">luaL_getmetafield</A><BR>
-<A HREF="manual.html#luaL_getmetatable">luaL_getmetatable</A><BR>
-<A HREF="manual.html#luaL_gsub">luaL_gsub</A><BR>
-<A HREF="manual.html#luaL_loadbuffer">luaL_loadbuffer</A><BR>
-<A HREF="manual.html#luaL_loadfile">luaL_loadfile</A><BR>
-<A HREF="manual.html#luaL_loadstring">luaL_loadstring</A><BR>
-<A HREF="manual.html#luaL_newmetatable">luaL_newmetatable</A><BR>
-<A HREF="manual.html#luaL_newstate">luaL_newstate</A><BR>
-<A HREF="manual.html#luaL_openlibs">luaL_openlibs</A><BR>
-<A HREF="manual.html#luaL_optint">luaL_optint</A><BR>
-<A HREF="manual.html#luaL_optinteger">luaL_optinteger</A><BR>
-<A HREF="manual.html#luaL_optlong">luaL_optlong</A><BR>
-<A HREF="manual.html#luaL_optlstring">luaL_optlstring</A><BR>
-<A HREF="manual.html#luaL_optnumber">luaL_optnumber</A><BR>
-<A HREF="manual.html#luaL_optstring">luaL_optstring</A><BR>
-<A HREF="manual.html#luaL_prepbuffer">luaL_prepbuffer</A><BR>
-<A HREF="manual.html#luaL_pushresult">luaL_pushresult</A><BR>
-<A HREF="manual.html#luaL_ref">luaL_ref</A><BR>
-<A HREF="manual.html#luaL_register">luaL_register</A><BR>
-<A HREF="manual.html#luaL_typename">luaL_typename</A><BR>
-<A HREF="manual.html#luaL_typerror">luaL_typerror</A><BR>
-<A HREF="manual.html#luaL_unref">luaL_unref</A><BR>
-<A HREF="manual.html#luaL_where">luaL_where</A><BR>
-
-</TD>
-</TR>
-</TABLE>
-<P>
-
-<HR>
-<SMALL>
-Last update:
-Sat Jan 19 13:24:29 BRST 2008
-</SMALL>
-<!--
-Last change: revised for Lua 5.1.3
--->
-
-</BODY>
-</HTML>

diff --git a/source3/lua-5.1.4/doc/cover.png b/source3/lua-5.1.4/doc/cover.png
deleted file mode 100644 (file)
index 2dbb198..0000000
Binary files a/source3/lua-5.1.4/doc/cover.png and /dev/null differ

diff --git a/source3/lua-5.1.4/doc/logo.gif b/source3/lua-5.1.4/doc/logo.gif
deleted file mode 100644 (file)
index 2f5e4ac..0000000
Binary files a/source3/lua-5.1.4/doc/logo.gif and /dev/null differ

diff --git a/source3/lua-5.1.4/doc/lua.css b/source3/lua-5.1.4/doc/lua.css
deleted file mode 100644 (file)
index 04f80b7..0000000
--- a/source3/lua-5.1.4/doc/lua.css
+++ /dev/null
@@ -1,40 +0,0 @@
-body {
-       color: #000000 ;
-       background-color: #FFFFFF ;
-       font-family: sans-serif ;
-       text-align: justify ;
-       margin-right: 20px ;
-       margin-left: 20px ;
-}
-
-h1, h2, h3, h4 {
-       font-weight: normal ;
-       font-style: italic ;
-}
-
-a:link {
-       color: #000080 ;
-       background-color: inherit ;
-       text-decoration: none ;
-}
-
-a:visited {
-       background-color: inherit ;
-       text-decoration: none ;
-}
-
-a:link:hover, a:visited:hover {
-       color: #000080 ;
-       background-color: #E0E0FF ;
-}
-
-a:link:active, a:visited:active {
-       color: #FF0000 ;
-}
-
-hr {
-       border: 0 ;
-       height: 1px ;
-       color: #a0a0a0 ;
-       background-color: #a0a0a0 ;
-}

diff --git a/source3/lua-5.1.4/doc/lua.html b/source3/lua-5.1.4/doc/lua.html
deleted file mode 100644 (file)
index 1d435ab..0000000
--- a/source3/lua-5.1.4/doc/lua.html
+++ /dev/null
@@ -1,172 +0,0 @@
-<!-- $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $ -->
-<HTML>
-<HEAD>
-<TITLE>LUA man page</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-</HEAD>
-
-<BODY BGCOLOR="#FFFFFF">
-
-<H2>NAME</H2>
-lua - Lua interpreter
-<H2>SYNOPSIS</H2>
-<B>lua</B>
-[
-<I>options</I>
-]
-[
-<I>script</I>
-[
-<I>args</I>
-]
-]
-<H2>DESCRIPTION</H2>
-<B>lua</B>
-is the stand-alone Lua interpreter.
-It loads and executes Lua programs,
-either in textual source form or
-in precompiled binary form.
-(Precompiled binaries are output by
-<B>luac</B>,
-the Lua compiler.)
-<B>lua</B>
-can be used as a batch interpreter and also interactively.
-<P>
-The given
-<I>options</I>
-(see below)
-are executed and then
-the Lua program in file
-<I>script</I>
-is loaded and executed.
-The given
-<I>args</I>
-are available to
-<I>script</I>
-as strings in a global table named
-<B>arg</B>.
-If these arguments contain spaces or other characters special to the shell,
-then they should be quoted
-(but note that the quotes will be removed by the shell).
-The arguments in
-<B>arg</B>
-start at 0,
-which contains the string
-'<I>script</I>'.
-The index of the last argument is stored in
-<B>arg.n</B>.
-The arguments given in the command line before
-<I>script</I>,
-including the name of the interpreter,
-are available in negative indices in
-<B>arg</B>.
-<P>
-At the very start,
-before even handling the command line,
-<B>lua</B>
-executes the contents of the environment variable
-<B>LUA_INIT</B>,
-if it is defined.
-If the value of
-<B>LUA_INIT</B>
-is of the form
-'@<I>filename</I>',
-then
-<I>filename</I>
-is executed.
-Otherwise, the string is assumed to be a Lua statement and is executed.
-<P>
-Options start with
-<B>'-'</B>
-and are described below.
-You can use
-<B>'--'</B>
-to signal the end of options.
-<P>
-If no arguments are given,
-then
-<B>"-v -i"</B>
-is assumed when the standard input is a terminal;
-otherwise,
-<B>"-"</B>
-is assumed.
-<P>
-In interactive mode,
-<B>lua</B>
-prompts the user,
-reads lines from the standard input,
-and executes them as they are read.
-If a line does not contain a complete statement,
-then a secondary prompt is displayed and
-lines are read until a complete statement is formed or
-a syntax error is found.
-So, one way to interrupt the reading of an incomplete statement is
-to force a syntax error:
-adding a
-<B>';'</B>
-in the middle of a statement is a sure way of forcing a syntax error
-(except inside multiline strings and comments; these must be closed explicitly).
-If a line starts with
-<B>'='</B>,
-then
-<B>lua</B>
-displays the values of all the expressions in the remainder of the
-line. The expressions must be separated by commas.
-The primary prompt is the value of the global variable
-<B>_PROMPT</B>,
-if this value is a string;
-otherwise, the default prompt is used.
-Similarly, the secondary prompt is the value of the global variable
-<B>_PROMPT2</B>.
-So,
-to change the prompts,
-set the corresponding variable to a string of your choice.
-You can do that after calling the interpreter
-or on the command line
-(but in this case you have to be careful with quotes
-if the prompt string contains a space; otherwise you may confuse the shell.)
-The default prompts are "&gt; " and "&gt;&gt; ".
-<H2>OPTIONS</H2>
-<P>
-<B>-</B>
-load and execute the standard input as a file,
-that is,
-not interactively,
-even when the standard input is a terminal.
-<P>
-<B>-e </B><I>stat</I>
-execute statement
-<I>stat</I>.
-You need to quote
-<I>stat </I>
-if it contains spaces, quotes,
-or other characters special to the shell.
-<P>
-<B>-i</B>
-enter interactive mode after
-<I>script</I>
-is executed.
-<P>
-<B>-l </B><I>name</I>
-call
-<B>require</B>('<I>name</I>')
-before executing
-<I>script</I>.
-Typically used to load libraries.
-<P>
-<B>-v</B>
-show version information.
-<H2>SEE ALSO</H2>
-<B>luac</B>(1)
-<BR>
-<A HREF="http://www.lua.org/">http://www.lua.org/</A>
-<H2>DIAGNOSTICS</H2>
-Error messages should be self explanatory.
-<H2>AUTHORS</H2>
-R. Ierusalimschy,
-L. H. de Figueiredo,
-and
-W. Celes
-<!-- EOF -->
-</BODY>
-</HTML>

diff --git a/source3/lua-5.1.4/doc/luac.html b/source3/lua-5.1.4/doc/luac.html
deleted file mode 100644 (file)
index 179ffe8..0000000
--- a/source3/lua-5.1.4/doc/luac.html
+++ /dev/null
@@ -1,145 +0,0 @@
-<!-- $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $ -->
-<HTML>
-<HEAD>
-<TITLE>LUAC man page</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-</HEAD>
-
-<BODY BGCOLOR="#FFFFFF">
-
-<H2>NAME</H2>
-luac - Lua compiler
-<H2>SYNOPSIS</H2>
-<B>luac</B>
-[
-<I>options</I>
-] [
-<I>filenames</I>
-]
-<H2>DESCRIPTION</H2>
-<B>luac</B>
-is the Lua compiler.
-It translates programs written in the Lua programming language
-into binary files that can be later loaded and executed.
-<P>
-The main advantages of precompiling chunks are:
-faster loading,
-protecting source code from accidental user changes,
-and
-off-line syntax checking.
-<P>
-Precompiling does not imply faster execution
-because in Lua chunks are always compiled into bytecodes before being executed.
-<B>luac</B>
-simply allows those bytecodes to be saved in a file for later execution.
-<P>
-Precompiled chunks are not necessarily smaller than the corresponding source.
-The main goal in precompiling is faster loading.
-<P>
-The binary files created by
-<B>luac</B>
-are portable only among architectures with the same word size and byte order.
-<P>
-<B>luac</B>
-produces a single output file containing the bytecodes
-for all source files given.
-By default,
-the output file is named
-<B>luac.out</B>,
-but you can change this with the
-<B>-o</B>
-option.
-<P>
-In the command line,
-you can mix
-text files containing Lua source and
-binary files containing precompiled chunks.
-This is useful because several precompiled chunks,
-even from different (but compatible) platforms,
-can be combined into a single precompiled chunk.
-<P>
-You can use
-<B>'-'</B>
-to indicate the standard input as a source file
-and
-<B>'--'</B>
-to signal the end of options
-(that is,
-all remaining arguments will be treated as files even if they start with
-<B>'-'</B>).
-<P>
-The internal format of the binary files produced by
-<B>luac</B>
-is likely to change when a new version of Lua is released.
-So,
-save the source files of all Lua programs that you precompile.
-<P>
-<H2>OPTIONS</H2>
-Options must be separate.
-<P>
-<B>-l</B>
-produce a listing of the compiled bytecode for Lua's virtual machine.
-Listing bytecodes is useful to learn about Lua's virtual machine.
-If no files are given, then
-<B>luac</B>
-loads
-<B>luac.out</B>
-and lists its contents.
-<P>
-<B>-o </B><I>file</I>
-output to
-<I>file</I>,
-instead of the default
-<B>luac.out</B>.
-(You can use
-<B>'-'</B>
-for standard output,
-but not on platforms that open standard output in text mode.)
-The output file may be a source file because
-all files are loaded before the output file is written.
-Be careful not to overwrite precious files.
-<P>
-<B>-p</B>
-load files but do not generate any output file.
-Used mainly for syntax checking and for testing precompiled chunks:
-corrupted files will probably generate errors when loaded.
-Lua always performs a thorough integrity test on precompiled chunks.
-Bytecode that passes this test is completely safe,
-in the sense that it will not break the interpreter.
-However,
-there is no guarantee that such code does anything sensible.
-(None can be given, because the halting problem is unsolvable.)
-If no files are given, then
-<B>luac</B>
-loads
-<B>luac.out</B>
-and tests its contents.
-No messages are displayed if the file passes the integrity test.
-<P>
-<B>-s</B>
-strip debug information before writing the output file.
-This saves some space in very large chunks,
-but if errors occur when running a stripped chunk,
-then the error messages may not contain the full information they usually do.
-For instance,
-line numbers and names of local variables are lost.
-<P>
-<B>-v</B>
-show version information.
-<H2>FILES</H2>
-<P>
-<B>luac.out</B>
-default output file
-<H2>SEE ALSO</H2>
-<B>lua</B>(1)
-<BR>
-<A HREF="http://www.lua.org/">http://www.lua.org/</A>
-<H2>DIAGNOSTICS</H2>
-Error messages should be self explanatory.
-<H2>AUTHORS</H2>
-L. H. de Figueiredo,
-R. Ierusalimschy and
-W. Celes
-<!-- EOF -->
-</BODY>
-</HTML>

diff --git a/source3/lua-5.1.4/doc/manual.css b/source3/lua-5.1.4/doc/manual.css
deleted file mode 100644 (file)
index 55683fe..0000000
--- a/source3/lua-5.1.4/doc/manual.css
+++ /dev/null
@@ -1,12 +0,0 @@
-h3 code {
-       font-family: inherit ;
-}
-
-pre {
-       font-size: 105% ;
-}
-
-span.apii {
-       float: right ;
-       font-family: inherit ;
-}

diff --git a/source3/lua-5.1.4/doc/manual.html b/source3/lua-5.1.4/doc/manual.html
deleted file mode 100644 (file)
index 118d905..0000000
--- a/source3/lua-5.1.4/doc/manual.html
+++ /dev/null
@@ -1,8800 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-
-<head>
-<title>Lua 5.1 Reference Manual</title>
-<link rel="stylesheet" type="text/css" href="lua.css">
-<link rel="stylesheet" type="text/css" href="manual.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-</head>
-
-<body>
-
-<hr>
-<h1>
-<a href="http://www.lua.org/"><img src="logo.gif" alt="" border="0"></a>
-Lua 5.1 Reference Manual
-</h1>
-
-by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
-<p>
-<small>
-Copyright &copy; 2006-2008 Lua.org, PUC-Rio.
-Freely available under the terms of the
-<a href="http://www.lua.org/license.html#5">Lua license</a>.
-</small>
-<hr>
-<p>
-
-<a href="contents.html#contents">contents</A>
-&middot;
-<a href="contents.html#index">index</A>
-
-<!-- ====================================================================== -->
-<p>
-
-<!-- $Id: manual.of,v 1.48 2008/08/18 15:24:20 roberto Exp $ -->
-
-
-
-
-<h1>1 - <a name="1">Introduction</a></h1>
-
-<p>
-Lua is an extension programming language designed to support
-general procedural programming with data description
-facilities.
-It also offers good support for object-oriented programming,
-functional programming, and data-driven programming.
-Lua is intended to be used as a powerful, light-weight
-scripting language for any program that needs one.
-Lua is implemented as a library, written in <em>clean</em> C
-(that is, in the common subset of ANSI&nbsp;C and C++).
-
-
-<p>
-Being an extension language, Lua has no notion of a "main" program:
-it only works <em>embedded</em> in a host client,
-called the <em>embedding program</em> or simply the <em>host</em>.
-This host program can invoke functions to execute a piece of Lua code,
-can write and read Lua variables,
-and can register C&nbsp;functions to be called by Lua code.
-Through the use of C&nbsp;functions, Lua can be augmented to cope with
-a wide range of different domains,
-thus creating customized programming languages sharing a syntactical framework.
-The Lua distribution includes a sample host program called <code>lua</code>,
-which uses the Lua library to offer a complete, stand-alone Lua interpreter.
-
-
-<p>
-Lua is free software,
-and is provided as usual with no guarantees,
-as stated in its license.
-The implementation described in this manual is available
-at Lua's official web site, <code>www.lua.org</code>.
-
-
-<p>
-Like any other reference manual,
-this document is dry in places.
-For a discussion of the decisions behind the design of Lua,
-see the technical papers available at Lua's web site.
-For a detailed introduction to programming in Lua,
-see Roberto's book, <em>Programming in Lua (Second Edition)</em>.
-
-
-
-<h1>2 - <a name="2">The Language</a></h1>
-
-<p>
-This section describes the lexis, the syntax, and the semantics of Lua.
-In other words,
-this section describes
-which tokens are valid,
-how they can be combined,
-and what their combinations mean.
-
-
-<p>
-The language constructs will be explained using the usual extended BNF notation,
-in which
-{<em>a</em>}&nbsp;means&nbsp;0 or more <em>a</em>'s, and
-[<em>a</em>]&nbsp;means an optional <em>a</em>.
-Non-terminals are shown like non-terminal,
-keywords are shown like <b>kword</b>,
-and other terminal symbols are shown like `<b>=</b>&acute;.
-The complete syntax of Lua can be found in <a href="#8">&sect;8</a>
-at the end of this manual.
-
-
-
-<h2>2.1 - <a name="2.1">Lexical Conventions</a></h2>
-
-<p>
-<em>Names</em>
-(also called <em>identifiers</em>)
-in Lua can be any string of letters,
-digits, and underscores,
-not beginning with a digit.
-This coincides with the definition of names in most languages.
-(The definition of letter depends on the current locale:
-any character considered alphabetic by the current locale
-can be used in an identifier.)
-Identifiers are used to name variables and table fields.
-
-
-<p>
-The following <em>keywords</em> are reserved
-and cannot be used as names:
-
-
-<pre>
-     and       break     do        else      elseif
-     end       false     for       function  if
-     in        local     nil       not       or
-     repeat    return    then      true      until     while
-</pre>
-
-<p>
-Lua is a case-sensitive language:
-<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
-are two different, valid names.
-As a convention, names starting with an underscore followed by
-uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>)
-are reserved for internal global variables used by Lua.
-
-
-<p>
-The following strings denote other tokens:
-
-<pre>
-     +     -     *     /     %     ^     #
-     ==    ~=    &lt;=    &gt;=    &lt;     &gt;     =
-     (     )     {     }     [     ]
-     ;     :     ,     .     ..    ...
-</pre>
-
-<p>
-<em>Literal strings</em>
-can be delimited by matching single or double quotes,
-and can contain the following C-like escape sequences:
-'<code>\a</code>' (bell),
-'<code>\b</code>' (backspace),
-'<code>\f</code>' (form feed),
-'<code>\n</code>' (newline),
-'<code>\r</code>' (carriage return),
-'<code>\t</code>' (horizontal tab),
-'<code>\v</code>' (vertical tab),
-'<code>\\</code>' (backslash),
-'<code>\"</code>' (quotation mark [double quote]),
-and '<code>\'</code>' (apostrophe [single quote]).
-Moreover, a backslash followed by a real newline
-results in a newline in the string.
-A character in a string can also be specified by its numerical value
-using the escape sequence <code>\<em>ddd</em></code>,
-where <em>ddd</em> is a sequence of up to three decimal digits.
-(Note that if a numerical escape is to be followed by a digit,
-it must be expressed using exactly three digits.)
-Strings in Lua can contain any 8-bit value, including embedded zeros,
-which can be specified as '<code>\0</code>'.
-
-
-<p>
-Literal strings can also be defined using a long format
-enclosed by <em>long brackets</em>.
-We define an <em>opening long bracket of level <em>n</em></em> as an opening
-square bracket followed by <em>n</em> equal signs followed by another
-opening square bracket.
-So, an opening long bracket of level&nbsp;0 is written as <code>[[</code>,
-an opening long bracket of level&nbsp;1 is written as <code>[=[</code>,
-and so on.
-A <em>closing long bracket</em> is defined similarly;
-for instance, a closing long bracket of level&nbsp;4 is written as <code>]====]</code>.
-A long string starts with an opening long bracket of any level and
-ends at the first closing long bracket of the same level.
-Literals in this bracketed form can run for several lines,
-do not interpret any escape sequences,
-and ignore long brackets of any other level.
-They can contain anything except a closing bracket of the proper level.
-
-
-<p>
-For convenience,
-when the opening long bracket is immediately followed by a newline,
-the newline is not included in the string.
-As an example, in a system using ASCII
-(in which '<code>a</code>' is coded as&nbsp;97,
-newline is coded as&nbsp;10, and '<code>1</code>' is coded as&nbsp;49),
-the five literal strings below denote the same string:
-
-<pre>
-     a = 'alo\n123"'
-     a = "alo\n123\""
-     a = '\97lo\10\04923"'
-     a = [[alo
-     123"]]
-     a = [==[
-     alo
-     123"]==]
-</pre>
-
-<p>
-A <em>numerical constant</em> can be written with an optional decimal part
-and an optional decimal exponent.
-Lua also accepts integer hexadecimal constants,
-by prefixing them with <code>0x</code>.
-Examples of valid numerical constants are
-
-<pre>
-     3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56
-</pre>
-
-<p>
-A <em>comment</em> starts with a double hyphen (<code>--</code>)
-anywhere outside a string.
-If the text immediately after <code>--</code> is not an opening long bracket,
-the comment is a <em>short comment</em>,
-which runs until the end of the line.
-Otherwise, it is a <em>long comment</em>,
-which runs until the corresponding closing long bracket.
-Long comments are frequently used to disable code temporarily.
-
-
-
-
-
-<h2>2.2 - <a name="2.2">Values and Types</a></h2>
-
-<p>
-Lua is a <em>dynamically typed language</em>.
-This means that
-variables do not have types; only values do.
-There are no type definitions in the language.
-All values carry their own type.
-
-
-<p>
-All values in Lua are <em>first-class values</em>.
-This means that all values can be stored in variables,
-passed as arguments to other functions, and returned as results.
-
-
-<p>
-There are eight basic types in Lua:
-<em>nil</em>, <em>boolean</em>, <em>number</em>,
-<em>string</em>, <em>function</em>, <em>userdata</em>,
-<em>thread</em>, and <em>table</em>.
-<em>Nil</em> is the type of the value <b>nil</b>,
-whose main property is to be different from any other value;
-it usually represents the absence of a useful value.
-<em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>.
-Both <b>nil</b> and <b>false</b> make a condition false;
-any other value makes it true.
-<em>Number</em> represents real (double-precision floating-point) numbers.
-(It is easy to build Lua interpreters that use other
-internal representations for numbers,
-such as single-precision float or long integers;
-see file <code>luaconf.h</code>.)
-<em>String</em> represents arrays of characters.
-
-Lua is 8-bit clean:
-strings can contain any 8-bit character,
-including embedded zeros ('<code>\0</code>') (see <a href="#2.1">&sect;2.1</a>).
-
-
-<p>
-Lua can call (and manipulate) functions written in Lua and
-functions written in C
-(see <a href="#2.5.8">&sect;2.5.8</a>).
-
-
-<p>
-The type <em>userdata</em> is provided to allow arbitrary C&nbsp;data to
-be stored in Lua variables.
-This type corresponds to a block of raw memory
-and has no pre-defined operations in Lua,
-except assignment and identity test.
-However, by using <em>metatables</em>,
-the programmer can define operations for userdata values
-(see <a href="#2.8">&sect;2.8</a>).
-Userdata values cannot be created or modified in Lua,
-only through the C&nbsp;API.
-This guarantees the integrity of data owned by the host program.
-
-
-<p>
-The type <em>thread</em> represents independent threads of execution
-and it is used to implement coroutines (see <a href="#2.11">&sect;2.11</a>).
-Do not confuse Lua threads with operating-system threads.
-Lua supports coroutines on all systems,
-even those that do not support threads.
-
-
-<p>
-The type <em>table</em> implements associative arrays,
-that is, arrays that can be indexed not only with numbers,
-but with any value (except <b>nil</b>).
-Tables can be <em>heterogeneous</em>;
-that is, they can contain values of all types (except <b>nil</b>).
-Tables are the sole data structuring mechanism in Lua;
-they can be used to represent ordinary arrays,
-symbol tables, sets, records, graphs, trees, etc.
-To represent records, Lua uses the field name as an index.
-The language supports this representation by
-providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
-There are several convenient ways to create tables in Lua
-(see <a href="#2.5.7">&sect;2.5.7</a>).
-
-
-<p>
-Like indices,
-the value of a table field can be of any type (except <b>nil</b>).
-In particular,
-because functions are first-class values,
-table fields can contain functions.
-Thus tables can also carry <em>methods</em> (see <a href="#2.5.9">&sect;2.5.9</a>).
-
-
-<p>
-Tables, functions, threads, and (full) userdata values are <em>objects</em>:
-variables do not actually <em>contain</em> these values,
-only <em>references</em> to them.
-Assignment, parameter passing, and function returns
-always manipulate references to such values;
-these operations do not imply any kind of copy.
-
-
-<p>
-The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
-of a given value.
-
-
-
-<h3>2.2.1 - <a name="2.2.1">Coercion</a></h3>
-
-<p>
-Lua provides automatic conversion between
-string and number values at run time.
-Any arithmetic operation applied to a string tries to convert
-this string to a number, following the usual conversion rules.
-Conversely, whenever a number is used where a string is expected,
-the number is converted to a string, in a reasonable format.
-For complete control over how numbers are converted to strings,
-use the <code>format</code> function from the string library
-(see <a href="#pdf-string.format"><code>string.format</code></a>).
-
-
-
-
-
-
-
-<h2>2.3 - <a name="2.3">Variables</a></h2>
-
-<p>
-Variables are places that store values.
-
-There are three kinds of variables in Lua:
-global variables, local variables, and table fields.
-
-
-<p>
-A single name can denote a global variable or a local variable
-(or a function's formal parameter,
-which is a particular kind of local variable):
-
-<pre>
-       var ::= Name
-</pre><p>
-Name denotes identifiers, as defined in <a href="#2.1">&sect;2.1</a>.
-
-
-<p>
-Any variable is assumed to be global unless explicitly declared
-as a local (see <a href="#2.4.7">&sect;2.4.7</a>).
-Local variables are <em>lexically scoped</em>:
-local variables can be freely accessed by functions
-defined inside their scope (see <a href="#2.6">&sect;2.6</a>).
-
-
-<p>
-Before the first assignment to a variable, its value is <b>nil</b>.
-
-
-<p>
-Square brackets are used to index a table:
-
-<pre>
-       var ::= prefixexp `<b>[</b>&acute; exp `<b>]</b>&acute;
-</pre><p>
-The meaning of accesses to global variables
-and table fields can be changed via metatables.
-An access to an indexed variable <code>t[i]</code> is equivalent to
-a call <code>gettable_event(t,i)</code>.
-(See <a href="#2.8">&sect;2.8</a> for a complete description of the
-<code>gettable_event</code> function.
-This function is not defined or callable in Lua.
-We use it here only for explanatory purposes.)
-
-
-<p>
-The syntax <code>var.Name</code> is just syntactic sugar for
-<code>var["Name"]</code>:
-
-<pre>
-       var ::= prefixexp `<b>.</b>&acute; Name
-</pre>
-
-<p>
-All global variables live as fields in ordinary Lua tables,
-called <em>environment tables</em> or simply
-<em>environments</em> (see <a href="#2.9">&sect;2.9</a>).
-Each function has its own reference to an environment,
-so that all global variables in this function
-will refer to this environment table.
-When a function is created,
-it inherits the environment from the function that created it.
-To get the environment table of a Lua function,
-you call <a href="#pdf-getfenv"><code>getfenv</code></a>.
-To replace it,
-you call <a href="#pdf-setfenv"><code>setfenv</code></a>.
-(You can only manipulate the environment of C&nbsp;functions
-through the debug library; (see <a href="#5.9">&sect;5.9</a>).)
-
-
-<p>
-An access to a global variable <code>x</code>
-is equivalent to <code>_env.x</code>,
-which in turn is equivalent to
-
-<pre>
-     gettable_event(_env, "x")
-</pre><p>
-where <code>_env</code> is the environment of the running function.
-(See <a href="#2.8">&sect;2.8</a> for a complete description of the
-<code>gettable_event</code> function.
-This function is not defined or callable in Lua.
-Similarly, the <code>_env</code> variable is not defined in Lua.
-We use them here only for explanatory purposes.)
-
-
-
-
-
-<h2>2.4 - <a name="2.4">Statements</a></h2>
-
-<p>
-Lua supports an almost conventional set of statements,
-similar to those in Pascal or C.
-This set includes
-assignments, control structures, function calls,
-and variable declarations.
-
-
-
-<h3>2.4.1 - <a name="2.4.1">Chunks</a></h3>
-
-<p>
-The unit of execution of Lua is called a <em>chunk</em>.
-A chunk is simply a sequence of statements,
-which are executed sequentially.
-Each statement can be optionally followed by a semicolon:
-
-<pre>
-       chunk ::= {stat [`<b>;</b>&acute;]}
-</pre><p>
-There are no empty statements and thus '<code>;;</code>' is not legal.
-
-
-<p>
-Lua handles a chunk as the body of an anonymous function
-with a variable number of arguments
-(see <a href="#2.5.9">&sect;2.5.9</a>).
-As such, chunks can define local variables,
-receive arguments, and return values.
-
-
-<p>
-A chunk can be stored in a file or in a string inside the host program.
-To execute a chunk,
-Lua first pre-compiles the chunk into instructions for a virtual machine,
-and then it executes the compiled code
-with an interpreter for the virtual machine.
-
-
-<p>
-Chunks can also be pre-compiled into binary form;
-see program <code>luac</code> for details.
-Programs in source and compiled forms are interchangeable;
-Lua automatically detects the file type and acts accordingly.
-
-
-
-
-
-
-<h3>2.4.2 - <a name="2.4.2">Blocks</a></h3><p>
-A block is a list of statements;
-syntactically, a block is the same as a chunk:
-
-<pre>
-       block ::= chunk
-</pre>
-
-<p>
-A block can be explicitly delimited to produce a single statement:
-
-<pre>
-       stat ::= <b>do</b> block <b>end</b>
-</pre><p>
-Explicit blocks are useful
-to control the scope of variable declarations.
-Explicit blocks are also sometimes used to
-add a <b>return</b> or <b>break</b> statement in the middle
-of another block (see <a href="#2.4.4">&sect;2.4.4</a>).
-
-
-
-
-
-<h3>2.4.3 - <a name="2.4.3">Assignment</a></h3>
-
-<p>
-Lua allows multiple assignments.
-Therefore, the syntax for assignment
-defines a list of variables on the left side
-and a list of expressions on the right side.
-The elements in both lists are separated by commas:
-
-<pre>
-       stat ::= varlist `<b>=</b>&acute; explist
-       varlist ::= var {`<b>,</b>&acute; var}
-       explist ::= exp {`<b>,</b>&acute; exp}
-</pre><p>
-Expressions are discussed in <a href="#2.5">&sect;2.5</a>.
-
-
-<p>
-Before the assignment,
-the list of values is <em>adjusted</em> to the length of
-the list of variables.
-If there are more values than needed,
-the excess values are thrown away.
-If there are fewer values than needed,
-the list is extended with as many  <b>nil</b>'s as needed.
-If the list of expressions ends with a function call,
-then all values returned by that call enter the list of values,
-before the adjustment
-(except when the call is enclosed in parentheses; see <a href="#2.5">&sect;2.5</a>).
-
-
-<p>
-The assignment statement first evaluates all its expressions
-and only then are the assignments performed.
-Thus the code
-
-<pre>
-     i = 3
-     i, a[i] = i+1, 20
-</pre><p>
-sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
-because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
-before it is assigned&nbsp;4.
-Similarly, the line
-
-<pre>
-     x, y = y, x
-</pre><p>
-exchanges the values of <code>x</code> and <code>y</code>,
-and
-
-<pre>
-     x, y, z = y, z, x
-</pre><p>
-cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
-
-
-<p>
-The meaning of assignments to global variables
-and table fields can be changed via metatables.
-An assignment to an indexed variable <code>t[i] = val</code> is equivalent to
-<code>settable_event(t,i,val)</code>.
-(See <a href="#2.8">&sect;2.8</a> for a complete description of the
-<code>settable_event</code> function.
-This function is not defined or callable in Lua.
-We use it here only for explanatory purposes.)
-
-
-<p>
-An assignment to a global variable <code>x = val</code>
-is equivalent to the assignment
-<code>_env.x = val</code>,
-which in turn is equivalent to
-
-<pre>
-     settable_event(_env, "x", val)
-</pre><p>
-where <code>_env</code> is the environment of the running function.
-(The <code>_env</code> variable is not defined in Lua.
-We use it here only for explanatory purposes.)
-
-
-
-
-
-<h3>2.4.4 - <a name="2.4.4">Control Structures</a></h3><p>
-The control structures
-<b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
-familiar syntax:
-
-
-
-
-<pre>
-       stat ::= <b>while</b> exp <b>do</b> block <b>end</b>
-       stat ::= <b>repeat</b> block <b>until</b> exp
-       stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
-</pre><p>
-Lua also has a <b>for</b> statement, in two flavors (see <a href="#2.4.5">&sect;2.4.5</a>).
-
-
-<p>
-The condition expression of a
-control structure can return any value.
-Both <b>false</b> and <b>nil</b> are considered false.
-All values different from <b>nil</b> and <b>false</b> are considered true
-(in particular, the number 0 and the empty string are also true).
-
-
-<p>
-In the <b>repeat</b>&ndash;<b>until</b> loop,
-the inner block does not end at the <b>until</b> keyword,
-but only after the condition.
-So, the condition can refer to local variables
-declared inside the loop block.
-
-
-<p>
-The <b>return</b> statement is used to return values
-from a function or a chunk (which is just a function).
-
-Functions and chunks can return more than one value,
-and so the syntax for the <b>return</b> statement is
-
-<pre>
-       stat ::= <b>return</b> [explist]
-</pre>
-
-<p>
-The <b>break</b> statement is used to terminate the execution of a
-<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
-skipping to the next statement after the loop:
-
-
-<pre>
-       stat ::= <b>break</b>
-</pre><p>
-A <b>break</b> ends the innermost enclosing loop.
-
-
-<p>
-The <b>return</b> and <b>break</b>
-statements can only be written as the <em>last</em> statement of a block.
-If it is really necessary to <b>return</b> or <b>break</b> in the
-middle of a block,
-then an explicit inner block can be used,
-as in the idioms
-<code>do return end</code> and <code>do break end</code>,
-because now <b>return</b> and <b>break</b> are the last statements in
-their (inner) blocks.
-
-
-
-
-
-<h3>2.4.5 - <a name="2.4.5">For Statement</a></h3>
-
-<p>
-
-The <b>for</b> statement has two forms:
-one numeric and one generic.
-
-
-<p>
-The numeric <b>for</b> loop repeats a block of code while a
-control variable runs through an arithmetic progression.
-It has the following syntax:
-
-<pre>
-       stat ::= <b>for</b> Name `<b>=</b>&acute; exp `<b>,</b>&acute; exp [`<b>,</b>&acute; exp] <b>do</b> block <b>end</b>
-</pre><p>
-The <em>block</em> is repeated for <em>name</em> starting at the value of
-the first <em>exp</em>, until it passes the second <em>exp</em> by steps of the
-third <em>exp</em>.
-More precisely, a <b>for</b> statement like
-
-<pre>
-     for v = <em>e1</em>, <em>e2</em>, <em>e3</em> do <em>block</em> end
-</pre><p>
-is equivalent to the code:
-
-<pre>
-     do
-       local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
-       if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
-       while (<em>step</em> &gt; 0 and <em>var</em> &lt;= <em>limit</em>) or (<em>step</em> &lt;= 0 and <em>var</em> &gt;= <em>limit</em>) do
-         local v = <em>var</em>
-         <em>block</em>
-         <em>var</em> = <em>var</em> + <em>step</em>
-       end
-     end
-</pre><p>
-Note the following:
-
-<ul>
-
-<li>
-All three control expressions are evaluated only once,
-before the loop starts.
-They must all result in numbers.
-</li>
-
-<li>
-<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
-The names shown here are for explanatory purposes only.
-</li>
-
-<li>
-If the third expression (the step) is absent,
-then a step of&nbsp;1 is used.
-</li>
-
-<li>
-You can use <b>break</b> to exit a <b>for</b> loop.
-</li>
-
-<li>
-The loop variable <code>v</code> is local to the loop;
-you cannot use its value after the <b>for</b> ends or is broken.
-If you need this value,
-assign it to another variable before breaking or exiting the loop.
-</li>
-
-</ul>
-
-<p>
-The generic <b>for</b> statement works over functions,
-called <em>iterators</em>.
-On each iteration, the iterator function is called to produce a new value,
-stopping when this new value is <b>nil</b>.
-The generic <b>for</b> loop has the following syntax:
-
-<pre>
-       stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
-       namelist ::= Name {`<b>,</b>&acute; Name}
-</pre><p>
-A <b>for</b> statement like
-
-<pre>
-     for <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> in <em>explist</em> do <em>block</em> end
-</pre><p>
-is equivalent to the code:
-
-<pre>
-     do
-       local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>
-       while true do
-         local <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
-         <em>var</em> = <em>var_1</em>
-         if <em>var</em> == nil then break end
-         <em>block</em>
-       end
-     end
-</pre><p>
-Note the following:
-
-<ul>
-
-<li>
-<code><em>explist</em></code> is evaluated only once.
-Its results are an <em>iterator</em> function,
-a <em>state</em>,
-and an initial value for the first <em>iterator variable</em>.
-</li>
-
-<li>
-<code><em>f</em></code>, <code><em>s</em></code>, and <code><em>var</em></code> are invisible variables.
-The names are here for explanatory purposes only.
-</li>
-
-<li>
-You can use <b>break</b> to exit a <b>for</b> loop.
-</li>
-
-<li>
-The loop variables <code><em>var_i</em></code> are local to the loop;
-you cannot use their values after the <b>for</b> ends.
-If you need these values,
-then assign them to other variables before breaking or exiting the loop.
-</li>
-
-</ul>
-
-
-
-
-<h3>2.4.6 - <a name="2.4.6">Function Calls as Statements</a></h3><p>
-To allow possible side-effects,
-function calls can be executed as statements:
-
-<pre>
-       stat ::= functioncall
-</pre><p>
-In this case, all returned values are thrown away.
-Function calls are explained in <a href="#2.5.8">&sect;2.5.8</a>.
-
-
-
-
-
-<h3>2.4.7 - <a name="2.4.7">Local Declarations</a></h3><p>
-Local variables can be declared anywhere inside a block.
-The declaration can include an initial assignment:
-
-<pre>
-       stat ::= <b>local</b> namelist [`<b>=</b>&acute; explist]
-</pre><p>
-If present, an initial assignment has the same semantics
-of a multiple assignment (see <a href="#2.4.3">&sect;2.4.3</a>).
-Otherwise, all variables are initialized with <b>nil</b>.
-
-
-<p>
-A chunk is also a block (see <a href="#2.4.1">&sect;2.4.1</a>),
-and so local variables can be declared in a chunk outside any explicit block.
-The scope of such local variables extends until the end of the chunk.
-
-
-<p>
-The visibility rules for local variables are explained in <a href="#2.6">&sect;2.6</a>.
-
-
-
-
-
-
-
-<h2>2.5 - <a name="2.5">Expressions</a></h2>
-
-<p>
-The basic expressions in Lua are the following:
-
-<pre>
-       exp ::= prefixexp
-       exp ::= <b>nil</b> | <b>false</b> | <b>true</b>
-       exp ::= Number
-       exp ::= String
-       exp ::= function
-       exp ::= tableconstructor
-       exp ::= `<b>...</b>&acute;
-       exp ::= exp binop exp
-       exp ::= unop exp
-       prefixexp ::= var | functioncall | `<b>(</b>&acute; exp `<b>)</b>&acute;
-</pre>
-
-<p>
-Numbers and literal strings are explained in <a href="#2.1">&sect;2.1</a>;
-variables are explained in <a href="#2.3">&sect;2.3</a>;
-function definitions are explained in <a href="#2.5.9">&sect;2.5.9</a>;
-function calls are explained in <a href="#2.5.8">&sect;2.5.8</a>;
-table constructors are explained in <a href="#2.5.7">&sect;2.5.7</a>.
-Vararg expressions,
-denoted by three dots ('<code>...</code>'), can only be used when
-directly inside a vararg function;
-they are explained in <a href="#2.5.9">&sect;2.5.9</a>.
-
-
-<p>
-Binary operators comprise arithmetic operators (see <a href="#2.5.1">&sect;2.5.1</a>),
-relational operators (see <a href="#2.5.2">&sect;2.5.2</a>), logical operators (see <a href="#2.5.3">&sect;2.5.3</a>),
-and the concatenation operator (see <a href="#2.5.4">&sect;2.5.4</a>).
-Unary operators comprise the unary minus (see <a href="#2.5.1">&sect;2.5.1</a>),
-the unary <b>not</b> (see <a href="#2.5.3">&sect;2.5.3</a>),
-and the unary <em>length operator</em> (see <a href="#2.5.5">&sect;2.5.5</a>).
-
-
-<p>
-Both function calls and vararg expressions can result in multiple values.
-If an expression is used as a statement
-(only possible for function calls (see <a href="#2.4.6">&sect;2.4.6</a>)),
-then its return list is adjusted to zero elements,
-thus discarding all returned values.
-If an expression is used as the last (or the only) element
-of a list of expressions,
-then no adjustment is made
-(unless the call is enclosed in parentheses).
-In all other contexts,
-Lua adjusts the result list to one element,
-discarding all values except the first one.
-
-
-<p>
-Here are some examples:
-
-<pre>
-     f()                -- adjusted to 0 results
-     g(f(), x)          -- f() is adjusted to 1 result
-     g(x, f())          -- g gets x plus all results from f()
-     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
-     a,b = ...          -- a gets the first vararg parameter, b gets
-                        -- the second (both a and b can get nil if there
-                        -- is no corresponding vararg parameter)
-
-     a,b,c = x, f()     -- f() is adjusted to 2 results
-     a,b,c = f()        -- f() is adjusted to 3 results
-     return f()         -- returns all results from f()
-     return ...         -- returns all received vararg parameters
-     return x,y,f()     -- returns x, y, and all results from f()
-     {f()}              -- creates a list with all results from f()
-     {...}              -- creates a list with all vararg parameters
-     {f(), nil}         -- f() is adjusted to 1 result
-</pre>
-
-<p>
-Any expression enclosed in parentheses always results in only one value.
-Thus,
-<code>(f(x,y,z))</code> is always a single value,
-even if <code>f</code> returns several values.
-(The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code>
-or <b>nil</b> if <code>f</code> does not return any values.)
-
-
-
-<h3>2.5.1 - <a name="2.5.1">Arithmetic Operators</a></h3><p>
-Lua supports the usual arithmetic operators:
-the binary <code>+</code> (addition),
-<code>-</code> (subtraction), <code>*</code> (multiplication),
-<code>/</code> (division), <code>%</code> (modulo), and <code>^</code> (exponentiation);
-and unary <code>-</code> (negation).
-If the operands are numbers, or strings that can be converted to
-numbers (see <a href="#2.2.1">&sect;2.2.1</a>),
-then all operations have the usual meaning.
-Exponentiation works for any exponent.
-For instance, <code>x^(-0.5)</code> computes the inverse of the square root of <code>x</code>.
-Modulo is defined as
-
-<pre>
-     a % b == a - math.floor(a/b)*b
-</pre><p>
-That is, it is the remainder of a division that rounds
-the quotient towards minus infinity.
-
-
-
-
-
-<h3>2.5.2 - <a name="2.5.2">Relational Operators</a></h3><p>
-The relational operators in Lua are
-
-<pre>
-     ==    ~=    &lt;     &gt;     &lt;=    &gt;=
-</pre><p>
-These operators always result in <b>false</b> or <b>true</b>.
-
-
-<p>
-Equality (<code>==</code>) first compares the type of its operands.
-If the types are different, then the result is <b>false</b>.
-Otherwise, the values of the operands are compared.
-Numbers and strings are compared in the usual way.
-Objects (tables, userdata, threads, and functions)
-are compared by <em>reference</em>:
-two objects are considered equal only if they are the <em>same</em> object.
-Every time you create a new object
-(a table, userdata, thread, or function),
-this new object is different from any previously existing object.
-
-
-<p>
-You can change the way that Lua compares tables and userdata
-by using the "eq" metamethod (see <a href="#2.8">&sect;2.8</a>).
-
-
-<p>
-The conversion rules of <a href="#2.2.1">&sect;2.2.1</a>
-<em>do not</em> apply to equality comparisons.
-Thus, <code>"0"==0</code> evaluates to <b>false</b>,
-and <code>t[0]</code> and <code>t["0"]</code> denote different
-entries in a table.
-
-
-<p>
-The operator <code>~=</code> is exactly the negation of equality (<code>==</code>).
-
-
-<p>
-The order operators work as follows.
-If both arguments are numbers, then they are compared as such.
-Otherwise, if both arguments are strings,
-then their values are compared according to the current locale.
-Otherwise, Lua tries to call the "lt" or the "le"
-metamethod (see <a href="#2.8">&sect;2.8</a>).
-A comparison <code>a &gt; b</code> is translated to <code>b &lt; a</code>
-and <code>a &gt;= b</code> is translated to <code>b &lt;= a</code>.
-
-
-
-
-
-<h3>2.5.3 - <a name="2.5.3">Logical Operators</a></h3><p>
-The logical operators in Lua are
-<b>and</b>, <b>or</b>, and <b>not</b>.
-Like the control structures (see <a href="#2.4.4">&sect;2.4.4</a>),
-all logical operators consider both <b>false</b> and <b>nil</b> as false
-and anything else as true.
-
-
-<p>
-The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
-The conjunction operator <b>and</b> returns its first argument
-if this value is <b>false</b> or <b>nil</b>;
-otherwise, <b>and</b> returns its second argument.
-The disjunction operator <b>or</b> returns its first argument
-if this value is different from <b>nil</b> and <b>false</b>;
-otherwise, <b>or</b> returns its second argument.
-Both <b>and</b> and <b>or</b> use short-cut evaluation;
-that is,
-the second operand is evaluated only if necessary.
-Here are some examples:
-
-<pre>
-     10 or 20            --&gt; 10
-     10 or error()       --&gt; 10
-     nil or "a"          --&gt; "a"
-     nil and 10          --&gt; nil
-     false and error()   --&gt; false
-     false and nil       --&gt; false
-     false or nil        --&gt; nil
-     10 and 20           --&gt; 20
-</pre><p>
-(In this manual,
-<code>--&gt;</code> indicates the result of the preceding expression.)
-
-
-
-
-
-<h3>2.5.4 - <a name="2.5.4">Concatenation</a></h3><p>
-The string concatenation operator in Lua is
-denoted by two dots ('<code>..</code>').
-If both operands are strings or numbers, then they are converted to
-strings according to the rules mentioned in <a href="#2.2.1">&sect;2.2.1</a>.
-Otherwise, the "concat" metamethod is called (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<h3>2.5.5 - <a name="2.5.5">The Length Operator</a></h3>
-
-<p>
-The length operator is denoted by the unary operator <code>#</code>.
-The length of a string is its number of bytes
-(that is, the usual meaning of string length when each
-character is one byte).
-
-
-<p>
-The length of a table <code>t</code> is defined to be any
-integer index <code>n</code>
-such that <code>t[n]</code> is not <b>nil</b> and <code>t[n+1]</code> is <b>nil</b>;
-moreover, if <code>t[1]</code> is <b>nil</b>, <code>n</code> can be zero.
-For a regular array, with non-nil values from 1 to a given <code>n</code>,
-its length is exactly that <code>n</code>,
-the index of its last value.
-If the array has "holes"
-(that is, <b>nil</b> values between other non-nil values),
-then <code>#t</code> can be any of the indices that
-directly precedes a <b>nil</b> value
-(that is, it may consider any such <b>nil</b> value as the end of
-the array).
-
-
-
-
-
-<h3>2.5.6 - <a name="2.5.6">Precedence</a></h3><p>
-Operator precedence in Lua follows the table below,
-from lower to higher priority:
-
-<pre>
-     or
-     and
-     &lt;     &gt;     &lt;=    &gt;=    ~=    ==
-     ..
-     +     -
-     *     /     %
-     not   #     - (unary)
-     ^
-</pre><p>
-As usual,
-you can use parentheses to change the precedences of an expression.
-The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>')
-operators are right associative.
-All other binary operators are left associative.
-
-
-
-
-
-<h3>2.5.7 - <a name="2.5.7">Table Constructors</a></h3><p>
-Table constructors are expressions that create tables.
-Every time a constructor is evaluated, a new table is created.
-A constructor can be used to create an empty table
-or to create a table and initialize some of its fields.
-The general syntax for constructors is
-
-<pre>
-       tableconstructor ::= `<b>{</b>&acute; [fieldlist] `<b>}</b>&acute;
-       fieldlist ::= field {fieldsep field} [fieldsep]
-       field ::= `<b>[</b>&acute; exp `<b>]</b>&acute; `<b>=</b>&acute; exp | Name `<b>=</b>&acute; exp | exp
-       fieldsep ::= `<b>,</b>&acute; | `<b>;</b>&acute;
-</pre>
-
-<p>
-Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry
-with key <code>exp1</code> and value <code>exp2</code>.
-A field of the form <code>name = exp</code> is equivalent to
-<code>["name"] = exp</code>.
-Finally, fields of the form <code>exp</code> are equivalent to
-<code>[i] = exp</code>, where <code>i</code> are consecutive numerical integers,
-starting with 1.
-Fields in the other formats do not affect this counting.
-For example,
-
-<pre>
-     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
-</pre><p>
-is equivalent to
-
-<pre>
-     do
-       local t = {}
-       t[f(1)] = g
-       t[1] = "x"         -- 1st exp
-       t[2] = "y"         -- 2nd exp
-       t.x = 1            -- t["x"] = 1
-       t[3] = f(x)        -- 3rd exp
-       t[30] = 23
-       t[4] = 45          -- 4th exp
-       a = t
-     end
-</pre>
-
-<p>
-If the last field in the list has the form <code>exp</code>
-and the expression is a function call or a vararg expression,
-then all values returned by this expression enter the list consecutively
-(see <a href="#2.5.8">&sect;2.5.8</a>).
-To avoid this,
-enclose the function call or the vararg expression
-in parentheses (see <a href="#2.5">&sect;2.5</a>).
-
-
-<p>
-The field list can have an optional trailing separator,
-as a convenience for machine-generated code.
-
-
-
-
-
-<h3>2.5.8 - <a name="2.5.8">Function Calls</a></h3><p>
-A function call in Lua has the following syntax:
-
-<pre>
-       functioncall ::= prefixexp args
-</pre><p>
-In a function call,
-first prefixexp and args are evaluated.
-If the value of prefixexp has type <em>function</em>,
-then this function is called
-with the given arguments.
-Otherwise, the prefixexp "call" metamethod is called,
-having as first parameter the value of prefixexp,
-followed by the original call arguments
-(see <a href="#2.8">&sect;2.8</a>).
-
-
-<p>
-The form
-
-<pre>
-       functioncall ::= prefixexp `<b>:</b>&acute; Name args
-</pre><p>
-can be used to call "methods".
-A call <code>v:name(<em>args</em>)</code>
-is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
-except that <code>v</code> is evaluated only once.
-
-
-<p>
-Arguments have the following syntax:
-
-<pre>
-       args ::= `<b>(</b>&acute; [explist] `<b>)</b>&acute;
-       args ::= tableconstructor
-       args ::= String
-</pre><p>
-All argument expressions are evaluated before the call.
-A call of the form <code>f{<em>fields</em>}</code> is
-syntactic sugar for <code>f({<em>fields</em>})</code>;
-that is, the argument list is a single new table.
-A call of the form <code>f'<em>string</em>'</code>
-(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
-is syntactic sugar for <code>f('<em>string</em>')</code>;
-that is, the argument list is a single literal string.
-
-
-<p>
-As an exception to the free-format syntax of Lua,
-you cannot put a line break before the '<code>(</code>' in a function call.
-This restriction avoids some ambiguities in the language.
-If you write
-
-<pre>
-     a = f
-     (g).x(a)
-</pre><p>
-Lua would see that as a single statement, <code>a = f(g).x(a)</code>.
-So, if you want two statements, you must add a semi-colon between them.
-If you actually want to call <code>f</code>,
-you must remove the line break before <code>(g)</code>.
-
-
-<p>
-A call of the form <code>return</code> <em>functioncall</em> is called
-a <em>tail call</em>.
-Lua implements <em>proper tail calls</em>
-(or <em>proper tail recursion</em>):
-in a tail call,
-the called function reuses the stack entry of the calling function.
-Therefore, there is no limit on the number of nested tail calls that
-a program can execute.
-However, a tail call erases any debug information about the
-calling function.
-Note that a tail call only happens with a particular syntax,
-where the <b>return</b> has one single function call as argument;
-this syntax makes the calling function return exactly
-the returns of the called function.
-So, none of the following examples are tail calls:
-
-<pre>
-     return (f(x))        -- results adjusted to 1
-     return 2 * f(x)
-     return x, f(x)       -- additional results
-     f(x); return         -- results discarded
-     return x or f(x)     -- results adjusted to 1
-</pre>
-
-
-
-
-<h3>2.5.9 - <a name="2.5.9">Function Definitions</a></h3>
-
-<p>
-The syntax for function definition is
-
-<pre>
-       function ::= <b>function</b> funcbody
-       funcbody ::= `<b>(</b>&acute; [parlist] `<b>)</b>&acute; block <b>end</b>
-</pre>
-
-<p>
-The following syntactic sugar simplifies function definitions:
-
-<pre>
-       stat ::= <b>function</b> funcname funcbody
-       stat ::= <b>local</b> <b>function</b> Name funcbody
-       funcname ::= Name {`<b>.</b>&acute; Name} [`<b>:</b>&acute; Name]
-</pre><p>
-The statement
-
-<pre>
-     function f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     f = function () <em>body</em> end
-</pre><p>
-The statement
-
-<pre>
-     function t.a.b.c.f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     t.a.b.c.f = function () <em>body</em> end
-</pre><p>
-The statement
-
-<pre>
-     local function f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     local f; f = function () <em>body</em> end
-</pre><p>
-<em>not</em> to
-
-<pre>
-     local f = function () <em>body</em> end
-</pre><p>
-(This only makes a difference when the body of the function
-contains references to <code>f</code>.)
-
-
-<p>
-A function definition is an executable expression,
-whose value has type <em>function</em>.
-When Lua pre-compiles a chunk,
-all its function bodies are pre-compiled too.
-Then, whenever Lua executes the function definition,
-the function is <em>instantiated</em> (or <em>closed</em>).
-This function instance (or <em>closure</em>)
-is the final value of the expression.
-Different instances of the same function
-can refer to different  external local variables
-and can have different environment tables.
-
-
-<p>
-Parameters act as local variables that are
-initialized with the argument values:
-
-<pre>
-       parlist ::= namelist [`<b>,</b>&acute; `<b>...</b>&acute;] | `<b>...</b>&acute;
-</pre><p>
-When a function is called,
-the list of arguments is adjusted to
-the length of the list of parameters,
-unless the function is a variadic or <em>vararg function</em>,
-which is
-indicated by three dots ('<code>...</code>') at the end of its parameter list.
-A vararg function does not adjust its argument list;
-instead, it collects all extra arguments and supplies them
-to the function through a <em>vararg expression</em>,
-which is also written as three dots.
-The value of this expression is a list of all actual extra arguments,
-similar to a function with multiple results.
-If a vararg expression is used inside another expression
-or in the middle of a list of expressions,
-then its return list is adjusted to one element.
-If the expression is used as the last element of a list of expressions,
-then no adjustment is made
-(unless that last expression is enclosed in parentheses).
-
-
-<p>
-As an example, consider the following definitions:
-
-<pre>
-     function f(a, b) end
-     function g(a, b, ...) end
-     function r() return 1,2,3 end
-</pre><p>
-Then, we have the following mapping from arguments to parameters and
-to the vararg expression:
-
-<pre>
-     CALL            PARAMETERS
-
-     f(3)             a=3, b=nil
-     f(3, 4)          a=3, b=4
-     f(3, 4, 5)       a=3, b=4
-     f(r(), 10)       a=1, b=10
-     f(r())           a=1, b=2
-
-     g(3)             a=3, b=nil, ... --&gt;  (nothing)
-     g(3, 4)          a=3, b=4,   ... --&gt;  (nothing)
-     g(3, 4, 5, 8)    a=3, b=4,   ... --&gt;  5  8
-     g(5, r())        a=5, b=1,   ... --&gt;  2  3
-</pre>
-
-<p>
-Results are returned using the <b>return</b> statement (see <a href="#2.4.4">&sect;2.4.4</a>).
-If control reaches the end of a function
-without encountering a <b>return</b> statement,
-then the function returns with no results.
-
-
-<p>
-The <em>colon</em> syntax
-is used for defining <em>methods</em>,
-that is, functions that have an implicit extra parameter <code>self</code>.
-Thus, the statement
-
-<pre>
-     function t.a.b.c:f (<em>params</em>) <em>body</em> end
-</pre><p>
-is syntactic sugar for
-
-<pre>
-     t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
-</pre>
-
-
-
-
-
-
-<h2>2.6 - <a name="2.6">Visibility Rules</a></h2>
-
-<p>
-
-Lua is a lexically scoped language.
-The scope of variables begins at the first statement <em>after</em>
-their declaration and lasts until the end of the innermost block that
-includes the declaration.
-Consider the following example:
-
-<pre>
-     x = 10                -- global variable
-     do                    -- new block
-       local x = x         -- new 'x', with value 10
-       print(x)            --&gt; 10
-       x = x+1
-       do                  -- another block
-         local x = x+1     -- another 'x'
-         print(x)          --&gt; 12
-       end
-       print(x)            --&gt; 11
-     end
-     print(x)              --&gt; 10  (the global one)
-</pre>
-
-<p>
-Notice that, in a declaration like <code>local x = x</code>,
-the new <code>x</code> being declared is not in scope yet,
-and so the second <code>x</code> refers to the outside variable.
-
-
-<p>
-Because of the lexical scoping rules,
-local variables can be freely accessed by functions
-defined inside their scope.
-A local variable used by an inner function is called
-an <em>upvalue</em>, or <em>external local variable</em>,
-inside the inner function.
-
-
-<p>
-Notice that each execution of a <b>local</b> statement
-defines new local variables.
-Consider the following example:
-
-<pre>
-     a = {}
-     local x = 20
-     for i=1,10 do
-       local y = 0
-       a[i] = function () y=y+1; return x+y end
-     end
-</pre><p>
-The loop creates ten closures
-(that is, ten instances of the anonymous function).
-Each of these closures uses a different <code>y</code> variable,
-while all of them share the same <code>x</code>.
-
-
-
-
-
-<h2>2.7 - <a name="2.7">Error Handling</a></h2>
-
-<p>
-Because Lua is an embedded extension language,
-all Lua actions start from C&nbsp;code in the host program
-calling a function from the Lua library (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
-Whenever an error occurs during Lua compilation or execution,
-control returns to C,
-which can take appropriate measures
-(such as printing an error message).
-
-
-<p>
-Lua code can explicitly generate an error by calling the
-<a href="#pdf-error"><code>error</code></a> function.
-If you need to catch errors in Lua,
-you can use the <a href="#pdf-pcall"><code>pcall</code></a> function.
-
-
-
-
-
-<h2>2.8 - <a name="2.8">Metatables</a></h2>
-
-<p>
-Every value in Lua can have a <em>metatable</em>.
-This <em>metatable</em> is an ordinary Lua table
-that defines the behavior of the original value
-under certain special operations.
-You can change several aspects of the behavior
-of operations over a value by setting specific fields in its metatable.
-For instance, when a non-numeric value is the operand of an addition,
-Lua checks for a function in the field <code>"__add"</code> in its metatable.
-If it finds one,
-Lua calls this function to perform the addition.
-
-
-<p>
-We call the keys in a metatable <em>events</em>
-and the values <em>metamethods</em>.
-In the previous example, the event is <code>"add"</code>
-and the metamethod is the function that performs the addition.
-
-
-<p>
-You can query the metatable of any value
-through the <a href="#pdf-getmetatable"><code>getmetatable</code></a> function.
-
-
-<p>
-You can replace the metatable of tables
-through the <a href="#pdf-setmetatable"><code>setmetatable</code></a>
-function.
-You cannot change the metatable of other types from Lua
-(except by using the debug library);
-you must use the C&nbsp;API for that.
-
-
-<p>
-Tables and full userdata have individual metatables
-(although multiple tables and userdata can share their metatables).
-Values of all other types share one single metatable per type;
-that is, there is one single metatable for all numbers,
-one for all strings, etc.
-
-
-<p>
-A metatable controls how an object behaves in arithmetic operations,
-order comparisons, concatenation, length operation, and indexing.
-A metatable also can define a function to be called when a userdata
-is garbage collected.
-For each of these operations Lua associates a specific key
-called an <em>event</em>.
-When Lua performs one of these operations over a value,
-it checks whether this value has a metatable with the corresponding event.
-If so, the value associated with that key (the metamethod)
-controls how Lua will perform the operation.
-
-
-<p>
-Metatables control the operations listed next.
-Each operation is identified by its corresponding name.
-The key for each operation is a string with its name prefixed by
-two underscores, '<code>__</code>';
-for instance, the key for operation "add" is the
-string <code>"__add"</code>.
-The semantics of these operations is better explained by a Lua function
-describing how the interpreter executes the operation.
-
-
-<p>
-The code shown here in Lua is only illustrative;
-the real behavior is hard coded in the interpreter
-and it is much more efficient than this simulation.
-All functions used in these descriptions
-(<a href="#pdf-rawget"><code>rawget</code></a>, <a href="#pdf-tonumber"><code>tonumber</code></a>, etc.)
-are described in <a href="#5.1">&sect;5.1</a>.
-In particular, to retrieve the metamethod of a given object,
-we use the expression
-
-<pre>
-     metatable(obj)[event]
-</pre><p>
-This should be read as
-
-<pre>
-     rawget(getmetatable(obj) or {}, event)
-</pre><p>
-
-That is, the access to a metamethod does not invoke other metamethods,
-and the access to objects with no metatables does not fail
-(it simply results in <b>nil</b>).
-
-
-
-<ul>
-
-<li><b>"add":</b>
-the <code>+</code> operation.
-
-
-
-<p>
-The function <code>getbinhandler</code> below defines how Lua chooses a handler
-for a binary operation.
-First, Lua tries the first operand.
-If its type does not define a handler for the operation,
-then Lua tries the second operand.
-
-<pre>
-     function getbinhandler (op1, op2, event)
-       return metatable(op1)[event] or metatable(op2)[event]
-     end
-</pre><p>
-By using this function,
-the behavior of the <code>op1 + op2</code> is
-
-<pre>
-     function add_event (op1, op2)
-       local o1, o2 = tonumber(op1), tonumber(op2)
-       if o1 and o2 then  -- both operands are numeric?
-         return o1 + o2   -- '+' here is the primitive 'add'
-       else  -- at least one of the operands is not numeric
-         local h = getbinhandler(op1, op2, "__add")
-         if h then
-           -- call the handler with both operands
-           return (h(op1, op2))
-         else  -- no handler available: default behavior
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"sub":</b>
-the <code>-</code> operation.
-
-Behavior similar to the "add" operation.
-</li>
-
-<li><b>"mul":</b>
-the <code>*</code> operation.
-
-Behavior similar to the "add" operation.
-</li>
-
-<li><b>"div":</b>
-the <code>/</code> operation.
-
-Behavior similar to the "add" operation.
-</li>
-
-<li><b>"mod":</b>
-the <code>%</code> operation.
-
-Behavior similar to the "add" operation,
-with the operation
-<code>o1 - floor(o1/o2)*o2</code> as the primitive operation.
-</li>
-
-<li><b>"pow":</b>
-the <code>^</code> (exponentiation) operation.
-
-Behavior similar to the "add" operation,
-with the function <code>pow</code> (from the C&nbsp;math library)
-as the primitive operation.
-</li>
-
-<li><b>"unm":</b>
-the unary <code>-</code> operation.
-
-
-<pre>
-     function unm_event (op)
-       local o = tonumber(op)
-       if o then  -- operand is numeric?
-         return -o  -- '-' here is the primitive 'unm'
-       else  -- the operand is not numeric.
-         -- Try to get a handler from the operand
-         local h = metatable(op).__unm
-         if h then
-           -- call the handler with the operand
-           return (h(op))
-         else  -- no handler available: default behavior
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"concat":</b>
-the <code>..</code> (concatenation) operation.
-
-
-<pre>
-     function concat_event (op1, op2)
-       if (type(op1) == "string" or type(op1) == "number") and
-          (type(op2) == "string" or type(op2) == "number") then
-         return op1 .. op2  -- primitive string concatenation
-       else
-         local h = getbinhandler(op1, op2, "__concat")
-         if h then
-           return (h(op1, op2))
-         else
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"len":</b>
-the <code>#</code> operation.
-
-
-<pre>
-     function len_event (op)
-       if type(op) == "string" then
-         return strlen(op)         -- primitive string length
-       elseif type(op) == "table" then
-         return #op                -- primitive table length
-       else
-         local h = metatable(op).__len
-         if h then
-           -- call the handler with the operand
-           return (h(op))
-         else  -- no handler available: default behavior
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-See <a href="#2.5.5">&sect;2.5.5</a> for a description of the length of a table.
-</li>
-
-<li><b>"eq":</b>
-the <code>==</code> operation.
-
-The function <code>getcomphandler</code> defines how Lua chooses a metamethod
-for comparison operators.
-A metamethod only is selected when both objects
-being compared have the same type
-and the same metamethod for the selected operation.
-
-<pre>
-     function getcomphandler (op1, op2, event)
-       if type(op1) ~= type(op2) then return nil end
-       local mm1 = metatable(op1)[event]
-       local mm2 = metatable(op2)[event]
-       if mm1 == mm2 then return mm1 else return nil end
-     end
-</pre><p>
-The "eq" event is defined as follows:
-
-<pre>
-     function eq_event (op1, op2)
-       if type(op1) ~= type(op2) then  -- different types?
-         return false   -- different objects
-       end
-       if op1 == op2 then   -- primitive equal?
-         return true   -- objects are equal
-       end
-       -- try metamethod
-       local h = getcomphandler(op1, op2, "__eq")
-       if h then
-         return (h(op1, op2))
-       else
-         return false
-       end
-     end
-</pre><p>
-<code>a ~= b</code> is equivalent to <code>not (a == b)</code>.
-</li>
-
-<li><b>"lt":</b>
-the <code>&lt;</code> operation.
-
-
-<pre>
-     function lt_event (op1, op2)
-       if type(op1) == "number" and type(op2) == "number" then
-         return op1 &lt; op2   -- numeric comparison
-       elseif type(op1) == "string" and type(op2) == "string" then
-         return op1 &lt; op2   -- lexicographic comparison
-       else
-         local h = getcomphandler(op1, op2, "__lt")
-         if h then
-           return (h(op1, op2))
-         else
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-<code>a &gt; b</code> is equivalent to <code>b &lt; a</code>.
-</li>
-
-<li><b>"le":</b>
-the <code>&lt;=</code> operation.
-
-
-<pre>
-     function le_event (op1, op2)
-       if type(op1) == "number" and type(op2) == "number" then
-         return op1 &lt;= op2   -- numeric comparison
-       elseif type(op1) == "string" and type(op2) == "string" then
-         return op1 &lt;= op2   -- lexicographic comparison
-       else
-         local h = getcomphandler(op1, op2, "__le")
-         if h then
-           return (h(op1, op2))
-         else
-           h = getcomphandler(op1, op2, "__lt")
-           if h then
-             return not h(op2, op1)
-           else
-             error(&middot;&middot;&middot;)
-           end
-         end
-       end
-     end
-</pre><p>
-<code>a &gt;= b</code> is equivalent to <code>b &lt;= a</code>.
-Note that, in the absence of a "le" metamethod,
-Lua tries the "lt", assuming that <code>a &lt;= b</code> is
-equivalent to <code>not (b &lt; a)</code>.
-</li>
-
-<li><b>"index":</b>
-The indexing access <code>table[key]</code>.
-
-
-<pre>
-     function gettable_event (table, key)
-       local h
-       if type(table) == "table" then
-         local v = rawget(table, key)
-         if v ~= nil then return v end
-         h = metatable(table).__index
-         if h == nil then return nil end
-       else
-         h = metatable(table).__index
-         if h == nil then
-           error(&middot;&middot;&middot;)
-         end
-       end
-       if type(h) == "function" then
-         return (h(table, key))     -- call the handler
-       else return h[key]           -- or repeat operation on it
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"newindex":</b>
-The indexing assignment <code>table[key] = value</code>.
-
-
-<pre>
-     function settable_event (table, key, value)
-       local h
-       if type(table) == "table" then
-         local v = rawget(table, key)
-         if v ~= nil then rawset(table, key, value); return end
-         h = metatable(table).__newindex
-         if h == nil then rawset(table, key, value); return end
-       else
-         h = metatable(table).__newindex
-         if h == nil then
-           error(&middot;&middot;&middot;)
-         end
-       end
-       if type(h) == "function" then
-         h(table, key,value)           -- call the handler
-       else h[key] = value             -- or repeat operation on it
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"call":</b>
-called when Lua calls a value.
-
-
-<pre>
-     function function_event (func, ...)
-       if type(func) == "function" then
-         return func(...)   -- primitive call
-       else
-         local h = metatable(func).__call
-         if h then
-           return h(func, ...)
-         else
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-</ul>
-
-
-
-
-<h2>2.9 - <a name="2.9">Environments</a></h2>
-
-<p>
-Besides metatables,
-objects of types thread, function, and userdata
-have another table associated with them,
-called their <em>environment</em>.
-Like metatables, environments are regular tables and
-multiple objects can share the same environment.
-
-
-<p>
-Threads are created sharing the environment of the creating thread.
-Userdata and C&nbsp;functions are created sharing the environment
-of the creating C&nbsp;function.
-Non-nested Lua functions
-(created by <a href="#pdf-loadfile"><code>loadfile</code></a>, <a href="#pdf-loadstring"><code>loadstring</code></a> or <a href="#pdf-load"><code>load</code></a>)
-are created sharing the environment of the creating thread.
-Nested Lua functions are created sharing the environment of
-the creating Lua function.
-
-
-<p>
-Environments associated with userdata have no meaning for Lua.
-It is only a convenience feature for programmers to associate a table to
-a userdata.
-
-
-<p>
-Environments associated with threads are called
-<em>global environments</em>.
-They are used as the default environment for threads and
-non-nested Lua functions created by the thread
-and can be directly accessed by C&nbsp;code (see <a href="#3.3">&sect;3.3</a>).
-
-
-<p>
-The environment associated with a C&nbsp;function can be directly
-accessed by C&nbsp;code (see <a href="#3.3">&sect;3.3</a>).
-It is used as the default environment for other C&nbsp;functions
-and userdata created by the function.
-
-
-<p>
-Environments associated with Lua functions are used to resolve
-all accesses to global variables within the function (see <a href="#2.3">&sect;2.3</a>).
-They are used as the default environment for nested Lua functions
-created by the function.
-
-
-<p>
-You can change the environment of a Lua function or the
-running thread by calling <a href="#pdf-setfenv"><code>setfenv</code></a>.
-You can get the environment of a Lua function or the running thread
-by calling <a href="#pdf-getfenv"><code>getfenv</code></a>.
-To manipulate the environment of other objects
-(userdata, C&nbsp;functions, other threads) you must
-use the C&nbsp;API.
-
-
-
-
-
-<h2>2.10 - <a name="2.10">Garbage Collection</a></h2>
-
-<p>
-Lua performs automatic memory management.
-This means that
-you have to worry neither about allocating memory for new objects
-nor about freeing it when the objects are no longer needed.
-Lua manages memory automatically by running
-a <em>garbage collector</em> from time to time
-to collect all <em>dead objects</em>
-(that is, objects that are no longer accessible from Lua).
-All memory used by Lua is subject to automatic management:
-tables, userdata, functions, threads, strings, etc.
-
-
-<p>
-Lua implements an incremental mark-and-sweep collector.
-It uses two numbers to control its garbage-collection cycles:
-the <em>garbage-collector pause</em> and
-the <em>garbage-collector step multiplier</em>.
-Both use percentage points as units
-(so that a value of 100 means an internal value of 1).
-
-
-<p>
-The garbage-collector pause
-controls how long the collector waits before starting a new cycle.
-Larger values make the collector less aggressive.
-Values smaller than 100 mean the collector will not wait to
-start a new cycle.
-A value of 200 means that the collector waits for the total memory in use
-to double before starting a new cycle.
-
-
-<p>
-The step multiplier
-controls the relative speed of the collector relative to
-memory allocation.
-Larger values make the collector more aggressive but also increase
-the size of each incremental step.
-Values smaller than 100 make the collector too slow and
-can result in the collector never finishing a cycle.
-The default, 200, means that the collector runs at "twice"
-the speed of memory allocation.
-
-
-<p>
-You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
-or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
-With these functions you can also control
-the collector directly (e.g., stop and restart it).
-
-
-
-<h3>2.10.1 - <a name="2.10.1">Garbage-Collection Metamethods</a></h3>
-
-<p>
-Using the C&nbsp;API,
-you can set garbage-collector metamethods for userdata (see <a href="#2.8">&sect;2.8</a>).
-These metamethods are also called <em>finalizers</em>.
-Finalizers allow you to coordinate Lua's garbage collection
-with external resource management
-(such as closing files, network or database connections,
-or freeing your own memory).
-
-
-<p>
-Garbage userdata with a field <code>__gc</code> in their metatables are not
-collected immediately by the garbage collector.
-Instead, Lua puts them in a list.
-After the collection,
-Lua does the equivalent of the following function
-for each userdata in that list:
-
-<pre>
-     function gc_event (udata)
-       local h = metatable(udata).__gc
-       if h then
-         h(udata)
-       end
-     end
-</pre>
-
-<p>
-At the end of each garbage-collection cycle,
-the finalizers for userdata are called in <em>reverse</em>
-order of their creation,
-among those collected in that cycle.
-That is, the first finalizer to be called is the one associated
-with the userdata created last in the program.
-The userdata itself is freed only in the next garbage-collection cycle.
-
-
-
-
-
-<h3>2.10.2 - <a name="2.10.2">Weak Tables</a></h3>
-
-<p>
-A <em>weak table</em> is a table whose elements are
-<em>weak references</em>.
-A weak reference is ignored by the garbage collector.
-In other words,
-if the only references to an object are weak references,
-then the garbage collector will collect this object.
-
-
-<p>
-A weak table can have weak keys, weak values, or both.
-A table with weak keys allows the collection of its keys,
-but prevents the collection of its values.
-A table with both weak keys and weak values allows the collection of
-both keys and values.
-In any case, if either the key or the value is collected,
-the whole pair is removed from the table.
-The weakness of a table is controlled by the
-<code>__mode</code> field of its metatable.
-If the <code>__mode</code> field is a string containing the character&nbsp;'<code>k</code>',
-the keys in the table are weak.
-If <code>__mode</code> contains '<code>v</code>',
-the values in the table are weak.
-
-
-<p>
-After you use a table as a metatable,
-you should not change the value of its <code>__mode</code> field.
-Otherwise, the weak behavior of the tables controlled by this
-metatable is undefined.
-
-
-
-
-
-
-
-<h2>2.11 - <a name="2.11">Coroutines</a></h2>
-
-<p>
-Lua supports coroutines,
-also called <em>collaborative multithreading</em>.
-A coroutine in Lua represents an independent thread of execution.
-Unlike threads in multithread systems, however,
-a coroutine only suspends its execution by explicitly calling
-a yield function.
-
-
-<p>
-You create a coroutine with a call to <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
-Its sole argument is a function
-that is the main function of the coroutine.
-The <code>create</code> function only creates a new coroutine and
-returns a handle to it (an object of type <em>thread</em>);
-it does not start the coroutine execution.
-
-
-<p>
-When you first call <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-passing as its first argument
-a thread returned by <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
-the coroutine starts its execution,
-at the first line of its main function.
-Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed on
-to the coroutine main function.
-After the coroutine starts running,
-it runs until it terminates or <em>yields</em>.
-
-
-<p>
-A coroutine can terminate its execution in two ways:
-normally, when its main function returns
-(explicitly or implicitly, after the last instruction);
-and abnormally, if there is an unprotected error.
-In the first case, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
-plus any values returned by the coroutine main function.
-In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
-plus an error message.
-
-
-<p>
-A coroutine yields by calling <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
-When a coroutine yields,
-the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
-even if the yield happens inside nested function calls
-(that is, not in the main function,
-but in a function directly or indirectly called by the main function).
-In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
-plus any values passed to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
-The next time you resume the same coroutine,
-it continues its execution from the point where it yielded,
-with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
-arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-
-
-<p>
-Like <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
-the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
-but instead of returning the coroutine itself,
-it returns a function that, when called, resumes the coroutine.
-Any arguments passed to this function
-go as extra arguments to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> returns all the values returned by <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-except the first one (the boolean error code).
-Unlike <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> does not catch errors;
-any error is propagated to the caller.
-
-
-<p>
-As an example,
-consider the following code:
-
-<pre>
-     function foo (a)
-       print("foo", a)
-       return coroutine.yield(2*a)
-     end
-
-     co = coroutine.create(function (a,b)
-           print("co-body", a, b)
-           local r = foo(a+1)
-           print("co-body", r)
-           local r, s = coroutine.yield(a+b, a-b)
-           print("co-body", r, s)
-           return b, "end"
-     end)
-
-     print("main", coroutine.resume(co, 1, 10))
-     print("main", coroutine.resume(co, "r"))
-     print("main", coroutine.resume(co, "x", "y"))
-     print("main", coroutine.resume(co, "x", "y"))
-</pre><p>
-When you run it, it produces the following output:
-
-<pre>
-     co-body 1       10
-     foo     2
-
-     main    true    4
-     co-body r
-     main    true    11      -9
-     co-body x       y
-     main    true    10      end
-     main    false   cannot resume dead coroutine
-</pre>
-
-
-
-
-<h1>3 - <a name="3">The Application Program Interface</a></h1>
-
-<p>
-
-This section describes the C&nbsp;API for Lua, that is,
-the set of C&nbsp;functions available to the host program to communicate
-with Lua.
-All API functions and related types and constants
-are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.
-
-
-<p>
-Even when we use the term "function",
-any facility in the API may be provided as a macro instead.
-All such macros use each of their arguments exactly once
-(except for the first argument, which is always a Lua state),
-and so do not generate any hidden side-effects.
-
-
-<p>
-As in most C&nbsp;libraries,
-the Lua API functions do not check their arguments for validity or consistency.
-However, you can change this behavior by compiling Lua
-with a proper definition for the macro <a name="pdf-luai_apicheck"><code>luai_apicheck</code></a>,
-in file <code>luaconf.h</code>.
-
-
-
-<h2>3.1 - <a name="3.1">The Stack</a></h2>
-
-<p>
-Lua uses a <em>virtual stack</em> to pass values to and from C.
-Each element in this stack represents a Lua value
-(<b>nil</b>, number, string, etc.).
-
-
-<p>
-Whenever Lua calls C, the called function gets a new stack,
-which is independent of previous stacks and of stacks of
-C&nbsp;functions that are still active.
-This stack initially contains any arguments to the C&nbsp;function
-and it is where the C&nbsp;function pushes its results
-to be returned to the caller (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-<p>
-For convenience,
-most query operations in the API do not follow a strict stack discipline.
-Instead, they can refer to any element in the stack
-by using an <em>index</em>:
-A positive index represents an <em>absolute</em> stack position
-(starting at&nbsp;1);
-a negative index represents an <em>offset</em> relative to the top of the stack.
-More specifically, if the stack has <em>n</em> elements,
-then index&nbsp;1 represents the first element
-(that is, the element that was pushed onto the stack first)
-and
-index&nbsp;<em>n</em> represents the last element;
-index&nbsp;-1 also represents the last element
-(that is, the element at the&nbsp;top)
-and index <em>-n</em> represents the first element.
-We say that an index is <em>valid</em>
-if it lies between&nbsp;1 and the stack top
-(that is, if <code>1 &le; abs(index) &le; top</code>).
-
-
-
-
-
-
-<h2>3.2 - <a name="3.2">Stack Size</a></h2>
-
-<p>
-When you interact with Lua API,
-you are responsible for ensuring consistency.
-In particular,
-<em>you are responsible for controlling stack overflow</em>.
-You can use the function <a href="#lua_checkstack"><code>lua_checkstack</code></a>
-to grow the stack size.
-
-
-<p>
-Whenever Lua calls C,
-it ensures that at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> stack positions are available.
-<code>LUA_MINSTACK</code> is defined as 20,
-so that usually you do not have to worry about stack space
-unless your code has loops pushing elements onto the stack.
-
-
-<p>
-Most query functions accept as indices any value inside the
-available stack space, that is, indices up to the maximum stack size
-you have set through <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
-Such indices are called <em>acceptable indices</em>.
-More formally, we define an <em>acceptable index</em>
-as follows:
-
-<pre>
-     (index &lt; 0 &amp;&amp; abs(index) &lt;= top) ||
-     (index &gt; 0 &amp;&amp; index &lt;= stackspace)
-</pre><p>
-Note that 0 is never an acceptable index.
-
-
-
-
-
-<h2>3.3 - <a name="3.3">Pseudo-Indices</a></h2>
-
-<p>
-Unless otherwise noted,
-any function that accepts valid indices can also be called with
-<em>pseudo-indices</em>,
-which represent some Lua values that are accessible to C&nbsp;code
-but which are not in the stack.
-Pseudo-indices are used to access the thread environment,
-the function environment,
-the registry,
-and the upvalues of a C&nbsp;function (see <a href="#3.4">&sect;3.4</a>).
-
-
-<p>
-The thread environment (where global variables live) is
-always at pseudo-index <a name="pdf-LUA_GLOBALSINDEX"><code>LUA_GLOBALSINDEX</code></a>.
-The environment of the running C&nbsp;function is always
-at pseudo-index <a name="pdf-LUA_ENVIRONINDEX"><code>LUA_ENVIRONINDEX</code></a>.
-
-
-<p>
-To access and change the value of global variables,
-you can use regular table operations over an environment table.
-For instance, to access the value of a global variable, do
-
-<pre>
-     lua_getfield(L, LUA_GLOBALSINDEX, varname);
-</pre>
-
-
-
-
-<h2>3.4 - <a name="3.4">C Closures</a></h2>
-
-<p>
-When a C&nbsp;function is created,
-it is possible to associate some values with it,
-thus creating a <em>C&nbsp;closure</em>;
-these values are called <em>upvalues</em> and are
-accessible to the function whenever it is called
-(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>).
-
-
-<p>
-Whenever a C&nbsp;function is called,
-its upvalues are located at specific pseudo-indices.
-These pseudo-indices are produced by the macro
-<a name="lua_upvalueindex"><code>lua_upvalueindex</code></a>.
-The first value associated with a function is at position
-<code>lua_upvalueindex(1)</code>, and so on.
-Any access to <code>lua_upvalueindex(<em>n</em>)</code>,
-where <em>n</em> is greater than the number of upvalues of the
-current function (but not greater than 256),
-produces an acceptable (but invalid) index.
-
-
-
-
-
-<h2>3.5 - <a name="3.5">Registry</a></h2>
-
-<p>
-Lua provides a <em>registry</em>,
-a pre-defined table that can be used by any C&nbsp;code to
-store whatever Lua value it needs to store.
-This table is always located at pseudo-index
-<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>.
-Any C&nbsp;library can store data into this table,
-but it should take care to choose keys different from those used
-by other libraries, to avoid collisions.
-Typically, you should use as key a string containing your library name
-or a light userdata with the address of a C&nbsp;object in your code.
-
-
-<p>
-The integer keys in the registry are used by the reference mechanism,
-implemented by the auxiliary library,
-and therefore should not be used for other purposes.
-
-
-
-
-
-<h2>3.6 - <a name="3.6">Error Handling in C</a></h2>
-
-<p>
-Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
-(You can also choose to use exceptions if you use C++;
-see file <code>luaconf.h</code>.)
-When Lua faces any error
-(such as memory allocation errors, type errors, syntax errors,
-and runtime errors)
-it <em>raises</em> an error;
-that is, it does a long jump.
-A <em>protected environment</em> uses <code>setjmp</code>
-to set a recover point;
-any error jumps to the most recent active recover point.
-
-
-<p>
-Most functions in the API can throw an error,
-for instance due to a memory allocation error.
-The documentation for each function indicates whether
-it can throw errors.
-
-
-<p>
-Inside a C&nbsp;function you can throw an error by calling <a href="#lua_error"><code>lua_error</code></a>.
-
-
-
-
-
-<h2>3.7 - <a name="3.7">Functions and Types</a></h2>
-
-<p>
-Here we list all functions and types from the C&nbsp;API in
-alphabetical order.
-Each function has an indicator like this:
-<span class="apii">[-o, +p, <em>x</em>]</span>
-
-
-<p>
-The first field, <code>o</code>,
-is how many elements the function pops from the stack.
-The second field, <code>p</code>,
-is how many elements the function pushes onto the stack.
-(Any function always pushes its results after popping its arguments.)
-A field in the form <code>x|y</code> means the function can push (or pop)
-<code>x</code> or <code>y</code> elements,
-depending on the situation;
-an interrogation mark '<code>?</code>' means that
-we cannot know how many elements the function pops/pushes
-by looking only at its arguments
-(e.g., they may depend on what is on the stack).
-The third field, <code>x</code>,
-tells whether the function may throw errors:
-'<code>-</code>' means the function never throws any error;
-'<code>m</code>' means the function may throw an error
-only due to not enough memory;
-'<code>e</code>' means the function may throw other kinds of errors;
-'<code>v</code>' means the function may throw an error on purpose.
-
-
-
-<hr><h3><a name="lua_Alloc"><code>lua_Alloc</code></a></h3>
-<pre>typedef void * (*lua_Alloc) (void *ud,
-                             void *ptr,
-                             size_t osize,
-                             size_t nsize);</pre>
-
-<p>
-The type of the memory-allocation function used by Lua states.
-The allocator function must provide a
-functionality similar to <code>realloc</code>,
-but not exactly the same.
-Its arguments are
-<code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
-<code>ptr</code>, a pointer to the block being allocated/reallocated/freed;
-<code>osize</code>, the original size of the block;
-<code>nsize</code>, the new size of the block.
-<code>ptr</code> is <code>NULL</code> if and only if <code>osize</code> is zero.
-When <code>nsize</code> is zero, the allocator must return <code>NULL</code>;
-if <code>osize</code> is not zero,
-it should free the block pointed to by <code>ptr</code>.
-When <code>nsize</code> is not zero, the allocator returns <code>NULL</code>
-if and only if it cannot fill the request.
-When <code>nsize</code> is not zero and <code>osize</code> is zero,
-the allocator should behave like <code>malloc</code>.
-When <code>nsize</code> and <code>osize</code> are not zero,
-the allocator behaves like <code>realloc</code>.
-Lua assumes that the allocator never fails when
-<code>osize &gt;= nsize</code>.
-
-
-<p>
-Here is a simple implementation for the allocator function.
-It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
-
-<pre>
-     static void *l_alloc (void *ud, void *ptr, size_t osize,
-                                                size_t nsize) {
-       (void)ud;  (void)osize;  /* not used */
-       if (nsize == 0) {
-         free(ptr);
-         return NULL;
-       }
-       else
-         return realloc(ptr, nsize);
-     }
-</pre><p>
-This code assumes
-that <code>free(NULL)</code> has no effect and that
-<code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.
-ANSI&nbsp;C ensures both behaviors.
-
-
-
-
-
-<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>
-
-<p>
-Sets a new panic function and returns the old one.
-
-
-<p>
-If an error happens outside any protected environment,
-Lua calls a <em>panic function</em>
-and then calls <code>exit(EXIT_FAILURE)</code>,
-thus exiting the host application.
-Your panic function can avoid this exit by
-never returning (e.g., doing a long jump).
-
-
-<p>
-The panic function can access the error message at the top of the stack.
-
-
-
-
-
-<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
-<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>
-
-<p>
-Calls a function.
-
-
-<p>
-To call a function you must use the following protocol:
-first, the function to be called is pushed onto the stack;
-then, the arguments to the function are pushed
-in direct order;
-that is, the first argument is pushed first.
-Finally you call <a href="#lua_call"><code>lua_call</code></a>;
-<code>nargs</code> is the number of arguments that you pushed onto the stack.
-All arguments and the function value are popped from the stack
-when the function is called.
-The function results are pushed onto the stack when the function returns.
-The number of results is adjusted to <code>nresults</code>,
-unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
-In this case, <em>all</em> results from the function are pushed.
-Lua takes care that the returned values fit into the stack space.
-The function results are pushed onto the stack in direct order
-(the first result is pushed first),
-so that after the call the last result is on the top of the stack.
-
-
-<p>
-Any error inside the called function is propagated upwards
-(with a <code>longjmp</code>).
-
-
-<p>
-The following example shows how the host program can do the
-equivalent to this Lua code:
-
-<pre>
-     a = f("how", t.x, 14)
-</pre><p>
-Here it is in&nbsp;C:
-
-<pre>
-     lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */
-     lua_pushstring(L, "how");                        /* 1st argument */
-     lua_getfield(L, LUA_GLOBALSINDEX, "t");   /* table to be indexed */
-     lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
-     lua_remove(L, -2);                  /* remove 't' from the stack */
-     lua_pushinteger(L, 14);                          /* 3rd argument */
-     lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
-     lua_setfield(L, LUA_GLOBALSINDEX, "a");        /* set global 'a' */
-</pre><p>
-Note that the code above is "balanced":
-at its end, the stack is back to its original configuration.
-This is considered good programming practice.
-
-
-
-
-
-<hr><h3><a name="lua_CFunction"><code>lua_CFunction</code></a></h3>
-<pre>typedef int (*lua_CFunction) (lua_State *L);</pre>
-
-<p>
-Type for C&nbsp;functions.
-
-
-<p>
-In order to communicate properly with Lua,
-a C&nbsp;function must use the following protocol,
-which defines the way parameters and results are passed:
-a C&nbsp;function receives its arguments from Lua in its stack
-in direct order (the first argument is pushed first).
-So, when the function starts,
-<code>lua_gettop(L)</code> returns the number of arguments received by the function.
-The first argument (if any) is at index 1
-and its last argument is at index <code>lua_gettop(L)</code>.
-To return values to Lua, a C&nbsp;function just pushes them onto the stack,
-in direct order (the first result is pushed first),
-and returns the number of results.
-Any other value in the stack below the results will be properly
-discarded by Lua.
-Like a Lua function, a C&nbsp;function called by Lua can also return
-many results.
-
-
-<p>
-As an example, the following function receives a variable number
-of numerical arguments and returns their average and sum:
-
-<pre>
-     static int foo (lua_State *L) {
-       int n = lua_gettop(L);    /* number of arguments */
-       lua_Number sum = 0;
-       int i;
-       for (i = 1; i &lt;= n; i++) {
-         if (!lua_isnumber(L, i)) {
-           lua_pushstring(L, "incorrect argument");
-           lua_error(L);
-         }
-         sum += lua_tonumber(L, i);
-       }
-       lua_pushnumber(L, sum/n);        /* first result */
-       lua_pushnumber(L, sum);         /* second result */
-       return 2;                   /* number of results */
-     }
-</pre>
-
-
-
-
-<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>int lua_checkstack (lua_State *L, int extra);</pre>
-
-<p>
-Ensures that there are at least <code>extra</code> free stack slots in the stack.
-It returns false if it cannot grow the stack to that size.
-This function never shrinks the stack;
-if the stack is already larger than the new size,
-it is left unchanged.
-
-
-
-
-
-<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void lua_close (lua_State *L);</pre>
-
-<p>
-Destroys all objects in the given Lua state
-(calling the corresponding garbage-collection metamethods, if any)
-and frees all dynamic memory used by this state.
-On several platforms, you may not need to call this function,
-because all resources are naturally released when the host program ends.
-On the other hand, long-running programs,
-such as a daemon or a web server,
-might need to release states as soon as they are not needed,
-to avoid growing too large.
-
-
-
-
-
-<hr><h3><a name="lua_concat"><code>lua_concat</code></a></h3><p>
-<span class="apii">[-n, +1, <em>e</em>]</span>
-<pre>void lua_concat (lua_State *L, int n);</pre>
-
-<p>
-Concatenates the <code>n</code> values at the top of the stack,
-pops them, and leaves the result at the top.
-If <code>n</code>&nbsp;is&nbsp;1, the result is the single value on the stack
-(that is, the function does nothing);
-if <code>n</code> is 0, the result is the empty string.
-Concatenation is performed following the usual semantics of Lua
-(see <a href="#2.5.4">&sect;2.5.4</a>).
-
-
-
-
-
-<hr><h3><a name="lua_cpcall"><code>lua_cpcall</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);</pre>
-
-<p>
-Calls the C&nbsp;function <code>func</code> in protected mode.
-<code>func</code> starts with only one element in its stack,
-a light userdata containing <code>ud</code>.
-In case of errors,
-<a href="#lua_cpcall"><code>lua_cpcall</code></a> returns the same error codes as <a href="#lua_pcall"><code>lua_pcall</code></a>,
-plus the error object on the top of the stack;
-otherwise, it returns zero, and does not change the stack.
-All values returned by <code>func</code> are discarded.
-
-
-
-
-
-<hr><h3><a name="lua_createtable"><code>lua_createtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_createtable (lua_State *L, int narr, int nrec);</pre>
-
-<p>
-Creates a new empty table and pushes it onto the stack.
-The new table has space pre-allocated
-for <code>narr</code> array elements and <code>nrec</code> non-array elements.
-This pre-allocation is useful when you know exactly how many elements
-the table will have.
-Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>int lua_dump (lua_State *L, lua_Writer writer, void *data);</pre>
-
-<p>
-Dumps a function as a binary chunk.
-Receives a Lua function on the top of the stack
-and produces a binary chunk that,
-if loaded again,
-results in a function equivalent to the one dumped.
-As it produces parts of the chunk,
-<a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
-with the given <code>data</code>
-to write them.
-
-
-<p>
-The value returned is the error code returned by the last
-call to the writer;
-0&nbsp;means no errors.
-
-
-<p>
-This function does not pop the Lua function from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_equal"><code>lua_equal</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_equal (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the two values in acceptable indices <code>index1</code> and
-<code>index2</code> are equal,
-following the semantics of the Lua <code>==</code> operator
-(that is, may call metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices is non valid.
-
-
-
-
-
-<hr><h3><a name="lua_error"><code>lua_error</code></a></h3><p>
-<span class="apii">[-1, +0, <em>v</em>]</span>
-<pre>int lua_error (lua_State *L);</pre>
-
-<p>
-Generates a Lua error.
-The error message (which can actually be a Lua value of any type)
-must be on the stack top.
-This function does a long jump,
-and therefore never returns.
-(see <a href="#luaL_error"><code>luaL_error</code></a>).
-
-
-
-
-
-<hr><h3><a name="lua_gc"><code>lua_gc</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_gc (lua_State *L, int what, int data);</pre>
-
-<p>
-Controls the garbage collector.
-
-
-<p>
-This function performs several tasks,
-according to the value of the parameter <code>what</code>:
-
-<ul>
-
-<li><b><code>LUA_GCSTOP</code>:</b>
-stops the garbage collector.
-</li>
-
-<li><b><code>LUA_GCRESTART</code>:</b>
-restarts the garbage collector.
-</li>
-
-<li><b><code>LUA_GCCOLLECT</code>:</b>
-performs a full garbage-collection cycle.
-</li>
-
-<li><b><code>LUA_GCCOUNT</code>:</b>
-returns the current amount of memory (in Kbytes) in use by Lua.
-</li>
-
-<li><b><code>LUA_GCCOUNTB</code>:</b>
-returns the remainder of dividing the current amount of bytes of
-memory in use by Lua by 1024.
-</li>
-
-<li><b><code>LUA_GCSTEP</code>:</b>
-performs an incremental step of garbage collection.
-The step "size" is controlled by <code>data</code>
-(larger values mean more steps) in a non-specified way.
-If you want to control the step size
-you must experimentally tune the value of <code>data</code>.
-The function returns 1 if the step finished a
-garbage-collection cycle.
-</li>
-
-<li><b><code>LUA_GCSETPAUSE</code>:</b>
-sets <code>data</code> as the new value
-for the <em>pause</em> of the collector (see <a href="#2.10">&sect;2.10</a>).
-The function returns the previous value of the pause.
-</li>
-
-<li><b><code>LUA_GCSETSTEPMUL</code>:</b>
-sets <code>data</code> as the new value for the <em>step multiplier</em> of
-the collector (see <a href="#2.10">&sect;2.10</a>).
-The function returns the previous value of the step multiplier.
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Alloc lua_getallocf (lua_State *L, void **ud);</pre>
-
-<p>
-Returns the memory-allocation function of a given state.
-If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
-opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_getfenv"><code>lua_getfenv</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_getfenv (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the environment table of
-the value at the given index.
-
-
-
-
-
-<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>void lua_getfield (lua_State *L, int index, const char *k);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the value at the given valid index.
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>void lua_getglobal (lua_State *L, const char *name);</pre>
-
-<p>
-Pushes onto the stack the value of the global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)
-</pre>
-
-
-
-
-<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>int lua_getmetatable (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the metatable of the value at the given
-acceptable index.
-If the index is not valid,
-or if the value does not have a metatable,
-the function returns&nbsp;0 and pushes nothing on the stack.
-
-
-
-
-
-<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
-<span class="apii">[-1, +1, <em>e</em>]</span>
-<pre>void lua_gettable (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the value at the given valid index
-and <code>k</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the key from the stack
-(putting the resulting value in its place).
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_gettop (lua_State *L);</pre>
-
-<p>
-Returns the index of the top element in the stack.
-Because indices start at&nbsp;1,
-this result is equal to the number of elements in the stack
-(and so 0&nbsp;means an empty stack).
-
-
-
-
-
-<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
-<span class="apii">[-1, +1, <em>-</em>]</span>
-<pre>void lua_insert (lua_State *L, int index);</pre>
-
-<p>
-Moves the top element into the given valid index,
-shifting up the elements above this index to open space.
-Cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
-<pre>typedef ptrdiff_t lua_Integer;</pre>
-
-<p>
-The type used by the Lua API to represent integral values.
-
-
-<p>
-By default it is a <code>ptrdiff_t</code>,
-which is usually the largest signed integral type the machine handles
-"comfortably".
-
-
-
-
-
-<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isboolean (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index has type boolean,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_iscfunction (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a C&nbsp;function,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isfunction (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a function
-(either C or Lua), and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_islightuserdata (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a light userdata,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnil (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is <b>nil</b>,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnone (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the given acceptable index is not valid
-(that is, it refers to an element outside the current stack),
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnoneornil (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the given acceptable index is not valid
-(that is, it refers to an element outside the current stack)
-or if the value at this index is <b>nil</b>,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnumber (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a number
-or a string convertible to a number,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isstring (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a string
-or a number (which is always convertible to a string),
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_istable (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a table,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isthread (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a thread,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isuserdata (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a userdata
-(either full or light), and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_lessthan"><code>lua_lessthan</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_lessthan (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the value at acceptable index <code>index1</code> is smaller
-than the value at acceptable index <code>index2</code>,
-following the semantics of the Lua <code>&lt;</code> operator
-(that is, may call metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices is non valid.
-
-
-
-
-
-<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>int lua_load (lua_State *L,
-              lua_Reader reader,
-              void *data,
-              const char *chunkname);</pre>
-
-<p>
-Loads a Lua chunk.
-If there are no errors,
-<a href="#lua_load"><code>lua_load</code></a> pushes the compiled chunk as a Lua
-function on top of the stack.
-Otherwise, it pushes an error message.
-The return values of <a href="#lua_load"><code>lua_load</code></a> are:
-
-<ul>
-
-<li><b>0:</b> no errors;</li>
-
-<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>:</b>
-syntax error during pre-compilation;</li>
-
-<li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>:</b>
-memory allocation error.</li>
-
-</ul>
-
-<p>
-This function only loads a chunk;
-it does not run it.
-
-
-<p>
-<a href="#lua_load"><code>lua_load</code></a> automatically detects whether the chunk is text or binary,
-and loads it accordingly (see program <code>luac</code>).
-
-
-<p>
-The <a href="#lua_load"><code>lua_load</code></a> function uses a user-supplied <code>reader</code> function
-to read the chunk (see <a href="#lua_Reader"><code>lua_Reader</code></a>).
-The <code>data</code> argument is an opaque value passed to the reader function.
-
-
-<p>
-The <code>chunkname</code> argument gives a name to the chunk,
-which is used for error messages and in debug information (see <a href="#3.8">&sect;3.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_State *lua_newstate (lua_Alloc f, void *ud);</pre>
-
-<p>
-Creates a new, independent state.
-Returns <code>NULL</code> if cannot create the state
-(due to lack of memory).
-The argument <code>f</code> is the allocator function;
-Lua does all memory allocation for this state through this function.
-The second argument, <code>ud</code>, is an opaque pointer that Lua
-simply passes to the allocator in every call.
-
-
-
-
-
-<hr><h3><a name="lua_newtable"><code>lua_newtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_newtable (lua_State *L);</pre>
-
-<p>
-Creates a new empty table and pushes it onto the stack.
-It is equivalent to <code>lua_createtable(L, 0, 0)</code>.
-
-
-
-
-
-<hr><h3><a name="lua_newthread"><code>lua_newthread</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>lua_State *lua_newthread (lua_State *L);</pre>
-
-<p>
-Creates a new thread, pushes it on the stack,
-and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
-The new state returned by this function shares with the original state
-all global objects (such as tables),
-but has an independent execution stack.
-
-
-<p>
-There is no explicit function to close or to destroy a thread.
-Threads are subject to garbage collection,
-like any Lua object.
-
-
-
-
-
-<hr><h3><a name="lua_newuserdata"><code>lua_newuserdata</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void *lua_newuserdata (lua_State *L, size_t size);</pre>
-
-<p>
-This function allocates a new block of memory with the given size,
-pushes onto the stack a new full userdata with the block address,
-and returns this address.
-
-
-<p>
-Userdata represent C&nbsp;values in Lua.
-A <em>full userdata</em> represents a block of memory.
-It is an object (like a table):
-you must create it, it can have its own metatable,
-and you can detect when it is being collected.
-A full userdata is only equal to itself (under raw equality).
-
-
-<p>
-When Lua collects a full userdata with a <code>gc</code> metamethod,
-Lua calls the metamethod and marks the userdata as finalized.
-When this userdata is collected again then
-Lua frees its corresponding memory.
-
-
-
-
-
-<hr><h3><a name="lua_next"><code>lua_next</code></a></h3><p>
-<span class="apii">[-1, +(2|0), <em>e</em>]</span>
-<pre>int lua_next (lua_State *L, int index);</pre>
-
-<p>
-Pops a key from the stack,
-and pushes a key-value pair from the table at the given index
-(the "next" pair after the given key).
-If there are no more elements in the table,
-then <a href="#lua_next"><code>lua_next</code></a> returns 0 (and pushes nothing).
-
-
-<p>
-A typical traversal looks like this:
-
-<pre>
-     /* table is in the stack at index 't' */
-     lua_pushnil(L);  /* first key */
-     while (lua_next(L, t) != 0) {
-       /* uses 'key' (at index -2) and 'value' (at index -1) */
-       printf("%s - %s\n",
-              lua_typename(L, lua_type(L, -2)),
-              lua_typename(L, lua_type(L, -1)));
-       /* removes 'value'; keeps 'key' for next iteration */
-       lua_pop(L, 1);
-     }
-</pre>
-
-<p>
-While traversing a table,
-do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,
-unless you know that the key is actually a string.
-Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> <em>changes</em>
-the value at the given index;
-this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_Number"><code>lua_Number</code></a></h3>
-<pre>typedef double lua_Number;</pre>
-
-<p>
-The type of numbers in Lua.
-By default, it is double, but that can be changed in <code>luaconf.h</code>.
-
-
-<p>
-Through the configuration file you can change
-Lua to operate with another type for numbers (e.g., float or long).
-
-
-
-
-
-<hr><h3><a name="lua_objlen"><code>lua_objlen</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>size_t lua_objlen (lua_State *L, int index);</pre>
-
-<p>
-Returns the "length" of the value at the given acceptable index:
-for strings, this is the string length;
-for tables, this is the result of the length operator ('<code>#</code>');
-for userdata, this is the size of the block of memory allocated
-for the userdata;
-for other values, it is&nbsp;0.
-
-
-
-
-
-<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +(nresults|1), <em>-</em>]</span>
-<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);</pre>
-
-<p>
-Calls a function in protected mode.
-
-
-<p>
-Both <code>nargs</code> and <code>nresults</code> have the same meaning as
-in <a href="#lua_call"><code>lua_call</code></a>.
-If there are no errors during the call,
-<a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>.
-However, if there is any error,
-<a href="#lua_pcall"><code>lua_pcall</code></a> catches it,
-pushes a single value on the stack (the error message),
-and returns an error code.
-Like <a href="#lua_call"><code>lua_call</code></a>,
-<a href="#lua_pcall"><code>lua_pcall</code></a> always removes the function
-and its arguments from the stack.
-
-
-<p>
-If <code>errfunc</code> is 0,
-then the error message returned on the stack
-is exactly the original error message.
-Otherwise, <code>errfunc</code> is the stack index of an
-<em>error handler function</em>.
-(In the current implementation, this index cannot be a pseudo-index.)
-In case of runtime errors,
-this function will be called with the error message
-and its return value will be the message returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
-
-
-<p>
-Typically, the error handler function is used to add more debug
-information to the error message, such as a stack traceback.
-Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
-since by then the stack has unwound.
-
-
-<p>
-The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns 0 in case of success
-or one of the following error codes
-(defined in <code>lua.h</code>):
-
-<ul>
-
-<li><b><a name="pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>:</b>
-a runtime error.
-</li>
-
-<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>:</b>
-memory allocation error.
-For such errors, Lua does not call the error handler function.
-</li>
-
-<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>:</b>
-error while running the error handler function.
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>
-<span class="apii">[-n, +0, <em>-</em>]</span>
-<pre>void lua_pop (lua_State *L, int n);</pre>
-
-<p>
-Pops <code>n</code> elements from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushboolean (lua_State *L, int b);</pre>
-
-<p>
-Pushes a boolean value with value <code>b</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushcclosure"><code>lua_pushcclosure</code></a></h3><p>
-<span class="apii">[-n, +1, <em>m</em>]</span>
-<pre>void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);</pre>
-
-<p>
-Pushes a new C&nbsp;closure onto the stack.
-
-
-<p>
-When a C&nbsp;function is created,
-it is possible to associate some values with it,
-thus creating a C&nbsp;closure (see <a href="#3.4">&sect;3.4</a>);
-these values are then accessible to the function whenever it is called.
-To associate values with a C&nbsp;function,
-first these values should be pushed onto the stack
-(when there are multiple values, the first value is pushed first).
-Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>
-is called to create and push the C&nbsp;function onto the stack,
-with the argument <code>n</code> telling how many values should be
-associated with the function.
-<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
-
-
-<p>
-The maximum value for <code>n</code> is 255.
-
-
-
-
-
-<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>
-
-<p>
-Pushes a C&nbsp;function onto the stack.
-This function receives a pointer to a C function
-and pushes onto the stack a Lua value of type <code>function</code> that,
-when called, invokes the corresponding C&nbsp;function.
-
-
-<p>
-Any function to be registered in Lua must
-follow the correct protocol to receive its parameters
-and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-<p>
-<code>lua_pushcfunction</code> is defined as a macro:
-
-<pre>
-     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
-</pre>
-
-
-
-
-<hr><h3><a name="lua_pushfstring"><code>lua_pushfstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushfstring (lua_State *L, const char *fmt, ...);</pre>
-
-<p>
-Pushes onto the stack a formatted string
-and returns a pointer to this string.
-It is similar to the C&nbsp;function <code>sprintf</code>,
-but has some important differences:
-
-<ul>
-
-<li>
-You do not have to allocate space for the result:
-the result is a Lua string and Lua takes care of memory allocation
-(and deallocation, through garbage collection).
-</li>
-
-<li>
-The conversion specifiers are quite restricted.
-There are no flags, widths, or precisions.
-The conversion specifiers can only be
-'<code>%%</code>' (inserts a '<code>%</code>' in the string),
-'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),
-'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
-'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),
-'<code>%d</code>' (inserts an <code>int</code>), and
-'<code>%c</code>' (inserts an <code>int</code> as a character).
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>
-
-<p>
-Pushes a number with value <code>n</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushlightuserdata (lua_State *L, void *p);</pre>
-
-<p>
-Pushes a light userdata onto the stack.
-
-
-<p>
-Userdata represent C&nbsp;values in Lua.
-A <em>light userdata</em> represents a pointer.
-It is a value (like a number):
-you do not create it, it has no individual metatable,
-and it is not collected (as it was never created).
-A light userdata is equal to "any"
-light userdata with the same C&nbsp;address.
-
-
-
-
-
-<hr><h3><a name="lua_pushliteral"><code>lua_pushliteral</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushliteral (lua_State *L, const char *s);</pre>
-
-<p>
-This macro is equivalent to <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>,
-but can be used only when <code>s</code> is a literal string.
-In these cases, it automatically provides the string length.
-
-
-
-
-
-<hr><h3><a name="lua_pushlstring"><code>lua_pushlstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushlstring (lua_State *L, const char *s, size_t len);</pre>
-
-<p>
-Pushes the string pointed to by <code>s</code> with size <code>len</code>
-onto the stack.
-Lua makes (or reuses) an internal copy of the given string,
-so the memory at <code>s</code> can be freed or reused immediately after
-the function returns.
-The string can contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushnil (lua_State *L);</pre>
-
-<p>
-Pushes a nil value onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
-
-<p>
-Pushes a number with value <code>n</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushstring"><code>lua_pushstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushstring (lua_State *L, const char *s);</pre>
-
-<p>
-Pushes the zero-terminated string pointed to by <code>s</code>
-onto the stack.
-Lua makes (or reuses) an internal copy of the given string,
-so the memory at <code>s</code> can be freed or reused immediately after
-the function returns.
-The string cannot contain embedded zeros;
-it is assumed to end at the first zero.
-
-
-
-
-
-<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>int lua_pushthread (lua_State *L);</pre>
-
-<p>
-Pushes the thread represented by <code>L</code> onto the stack.
-Returns 1 if this thread is the main thread of its state.
-
-
-
-
-
-<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushvalue (lua_State *L, int index);</pre>
-
-<p>
-Pushes a copy of the element at the given valid index
-onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushvfstring"><code>lua_pushvfstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushvfstring (lua_State *L,
-                              const char *fmt,
-                              va_list argp);</pre>
-
-<p>
-Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code>
-instead of a variable number of arguments.
-
-
-
-
-
-<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the two values in acceptable indices <code>index1</code> and
-<code>index2</code> are primitively equal
-(that is, without calling metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices are non valid.
-
-
-
-
-
-<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
-<span class="apii">[-1, +1, <em>-</em>]</span>
-<pre>void lua_rawget (lua_State *L, int index);</pre>
-
-<p>
-Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access
-(i.e., without metamethods).
-
-
-
-
-
-<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_rawgeti (lua_State *L, int index, int n);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[n]</code>,
-where <code>t</code> is the value at the given valid index.
-The access is raw;
-that is, it does not invoke metamethods.
-
-
-
-
-
-<hr><h3><a name="lua_rawset"><code>lua_rawset</code></a></h3><p>
-<span class="apii">[-2, +0, <em>m</em>]</span>
-<pre>void lua_rawset (lua_State *L, int index);</pre>
-
-<p>
-Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment
-(i.e., without metamethods).
-
-
-
-
-
-<hr><h3><a name="lua_rawseti"><code>lua_rawseti</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>void lua_rawseti (lua_State *L, int index, int n);</pre>
-
-<p>
-Does the equivalent of <code>t[n] = v</code>,
-where <code>t</code> is the value at the given valid index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-The assignment is raw;
-that is, it does not invoke metamethods.
-
-
-
-
-
-<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>
-<pre>typedef const char * (*lua_Reader) (lua_State *L,
-                                    void *data,
-                                    size_t *size);</pre>
-
-<p>
-The reader function used by <a href="#lua_load"><code>lua_load</code></a>.
-Every time it needs another piece of the chunk,
-<a href="#lua_load"><code>lua_load</code></a> calls the reader,
-passing along its <code>data</code> parameter.
-The reader must return a pointer to a block of memory
-with a new piece of the chunk
-and set <code>size</code> to the block size.
-The block must exist until the reader function is called again.
-To signal the end of the chunk,
-the reader must return <code>NULL</code> or set <code>size</code> to zero.
-The reader function may return pieces of any size greater than zero.
-
-
-
-
-
-<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>void lua_register (lua_State *L,
-                   const char *name,
-                   lua_CFunction f);</pre>
-
-<p>
-Sets the C function <code>f</code> as the new value of global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_register(L,n,f) \
-            (lua_pushcfunction(L, f), lua_setglobal(L, n))
-</pre>
-
-
-
-
-<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>void lua_remove (lua_State *L, int index);</pre>
-
-<p>
-Removes the element at the given valid index,
-shifting down the elements above this index to fill the gap.
-Cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>void lua_replace (lua_State *L, int index);</pre>
-
-<p>
-Moves the top element into the given position (and pops it),
-without shifting any element
-(therefore replacing the value at the given position).
-
-
-
-
-
-<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>int lua_resume (lua_State *L, int narg);</pre>
-
-<p>
-Starts and resumes a coroutine in a given thread.
-
-
-<p>
-To start a coroutine, you first create a new thread
-(see <a href="#lua_newthread"><code>lua_newthread</code></a>);
-then you push onto its stack the main function plus any arguments;
-then you call <a href="#lua_resume"><code>lua_resume</code></a>,
-with <code>narg</code> being the number of arguments.
-This call returns when the coroutine suspends or finishes its execution.
-When it returns, the stack contains all values passed to <a href="#lua_yield"><code>lua_yield</code></a>,
-or all values returned by the body function.
-<a href="#lua_resume"><code>lua_resume</code></a> returns
-<a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the coroutine yields,
-0 if the coroutine finishes its execution
-without errors,
-or an error code in case of errors (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
-In case of errors,
-the stack is not unwound,
-so you can use the debug API over it.
-The error message is on the top of the stack.
-To restart a coroutine, you put on its stack only the values to
-be passed as results from <code>yield</code>,
-and then call <a href="#lua_resume"><code>lua_resume</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);</pre>
-
-<p>
-Changes the allocator function of a given state to <code>f</code>
-with user data <code>ud</code>.
-
-
-
-
-
-<hr><h3><a name="lua_setfenv"><code>lua_setfenv</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>int lua_setfenv (lua_State *L, int index);</pre>
-
-<p>
-Pops a table from the stack and sets it as
-the new environment for the value at the given index.
-If the value at the given index is
-neither a function nor a thread nor a userdata,
-<a href="#lua_setfenv"><code>lua_setfenv</code></a> returns 0.
-Otherwise it returns 1.
-
-
-
-
-
-<hr><h3><a name="lua_setfield"><code>lua_setfield</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_setfield (lua_State *L, int index, const char *k);</pre>
-
-<p>
-Does the equivalent to <code>t[k] = v</code>,
-where <code>t</code> is the value at the given valid index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_setglobal"><code>lua_setglobal</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_setglobal (lua_State *L, const char *name);</pre>
-
-<p>
-Pops a value from the stack and
-sets it as the new value of global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)
-</pre>
-
-
-
-
-<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>int lua_setmetatable (lua_State *L, int index);</pre>
-
-<p>
-Pops a table from the stack and
-sets it as the new metatable for the value at the given
-acceptable index.
-
-
-
-
-
-<hr><h3><a name="lua_settable"><code>lua_settable</code></a></h3><p>
-<span class="apii">[-2, +0, <em>e</em>]</span>
-<pre>void lua_settable (lua_State *L, int index);</pre>
-
-<p>
-Does the equivalent to <code>t[k] = v</code>,
-where <code>t</code> is the value at the given valid index,
-<code>v</code> is the value at the top of the stack,
-and <code>k</code> is the value just below the top.
-
-
-<p>
-This function pops both the key and the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>void lua_settop (lua_State *L, int index);</pre>
-
-<p>
-Accepts any acceptable index, or&nbsp;0,
-and sets the stack top to this index.
-If the new top is larger than the old one,
-then the new elements are filled with <b>nil</b>.
-If <code>index</code> is&nbsp;0, then all stack elements are removed.
-
-
-
-
-
-<hr><h3><a name="lua_State"><code>lua_State</code></a></h3>
-<pre>typedef struct lua_State lua_State;</pre>
-
-<p>
-Opaque structure that keeps the whole state of a Lua interpreter.
-The Lua library is fully reentrant:
-it has no global variables.
-All information about a state is kept in this structure.
-
-
-<p>
-A pointer to this state must be passed as the first argument to
-every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
-which creates a Lua state from scratch.
-
-
-
-
-
-<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_status (lua_State *L);</pre>
-
-<p>
-Returns the status of the thread <code>L</code>.
-
-
-<p>
-The status can be 0 for a normal thread,
-an error code if the thread finished its execution with an error,
-or <a name="pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the thread is suspended.
-
-
-
-
-
-<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_toboolean (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index to a C&nbsp;boolean
-value (0&nbsp;or&nbsp;1).
-Like all tests in Lua,
-<a href="#lua_toboolean"><code>lua_toboolean</code></a> returns 1 for any Lua value
-different from <b>false</b> and <b>nil</b>;
-otherwise it returns 0.
-It also returns 0 when called with a non-valid index.
-(If you want to accept only actual boolean values,
-use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's type.)
-
-
-
-
-
-<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>
-
-<p>
-Converts a value at the given acceptable index to a C&nbsp;function.
-That value must be a C&nbsp;function;
-otherwise, returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index
-to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
-The Lua value must be a number or a string convertible to a number
-(see <a href="#2.2.1">&sect;2.2.1</a>);
-otherwise, <a href="#lua_tointeger"><code>lua_tointeger</code></a> returns&nbsp;0.
-
-
-<p>
-If the number is not an integer,
-it is truncated in some non-specified way.
-
-
-
-
-
-<hr><h3><a name="lua_tolstring"><code>lua_tolstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>const char *lua_tolstring (lua_State *L, int index, size_t *len);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index to a C&nbsp;string.
-If <code>len</code> is not <code>NULL</code>,
-it also sets <code>*len</code> with the string length.
-The Lua value must be a string or a number;
-otherwise, the function returns <code>NULL</code>.
-If the value is a number,
-then <a href="#lua_tolstring"><code>lua_tolstring</code></a> also
-<em>changes the actual value in the stack to a string</em>.
-(This change confuses <a href="#lua_next"><code>lua_next</code></a>
-when <a href="#lua_tolstring"><code>lua_tolstring</code></a> is applied to keys during a table traversal.)
-
-
-<p>
-<a href="#lua_tolstring"><code>lua_tolstring</code></a> returns a fully aligned pointer
-to a string inside the Lua state.
-This string always has a zero ('<code>\0</code>')
-after its last character (as in&nbsp;C),
-but can contain other zeros in its body.
-Because Lua has garbage collection,
-there is no guarantee that the pointer returned by <a href="#lua_tolstring"><code>lua_tolstring</code></a>
-will be valid after the corresponding value is removed from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index
-to the C&nbsp;type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
-The Lua value must be a number or a string convertible to a number
-(see <a href="#2.2.1">&sect;2.2.1</a>);
-otherwise, <a href="#lua_tonumber"><code>lua_tonumber</code></a> returns&nbsp;0.
-
-
-
-
-
-<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>const void *lua_topointer (lua_State *L, int index);</pre>
-
-<p>
-Converts the value at the given acceptable index to a generic
-C&nbsp;pointer (<code>void*</code>).
-The value can be a userdata, a table, a thread, or a function;
-otherwise, <a href="#lua_topointer"><code>lua_topointer</code></a> returns <code>NULL</code>.
-Different objects will give different pointers.
-There is no way to convert the pointer back to its original value.
-
-
-<p>
-Typically this function is used only for debug information.
-
-
-
-
-
-<hr><h3><a name="lua_tostring"><code>lua_tostring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>const char *lua_tostring (lua_State *L, int index);</pre>
-
-<p>
-Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_State *lua_tothread (lua_State *L, int index);</pre>
-
-<p>
-Converts the value at the given acceptable index to a Lua thread
-(represented as <code>lua_State*</code>).
-This value must be a thread;
-otherwise, the function returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void *lua_touserdata (lua_State *L, int index);</pre>
-
-<p>
-If the value at the given acceptable index is a full userdata,
-returns its block address.
-If the value is a light userdata,
-returns its pointer.
-Otherwise, returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_type (lua_State *L, int index);</pre>
-
-<p>
-Returns the type of the value in the given acceptable index,
-or <code>LUA_TNONE</code> for a non-valid index
-(that is, an index to an "empty" stack position).
-The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
-defined in <code>lua.h</code>:
-<code>LUA_TNIL</code>,
-<code>LUA_TNUMBER</code>,
-<code>LUA_TBOOLEAN</code>,
-<code>LUA_TSTRING</code>,
-<code>LUA_TTABLE</code>,
-<code>LUA_TFUNCTION</code>,
-<code>LUA_TUSERDATA</code>,
-<code>LUA_TTHREAD</code>,
-and
-<code>LUA_TLIGHTUSERDATA</code>.
-
-
-
-
-
-<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>const char *lua_typename  (lua_State *L, int tp);</pre>
-
-<p>
-Returns the name of the type encoded by the value <code>tp</code>,
-which must be one the values returned by <a href="#lua_type"><code>lua_type</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_Writer"><code>lua_Writer</code></a></h3>
-<pre>typedef int (*lua_Writer) (lua_State *L,
-                           const void* p,
-                           size_t sz,
-                           void* ud);</pre>
-
-<p>
-The type of the writer function used by <a href="#lua_dump"><code>lua_dump</code></a>.
-Every time it produces another piece of chunk,
-<a href="#lua_dump"><code>lua_dump</code></a> calls the writer,
-passing along the buffer to be written (<code>p</code>),
-its size (<code>sz</code>),
-and the <code>data</code> parameter supplied to <a href="#lua_dump"><code>lua_dump</code></a>.
-
-
-<p>
-The writer returns an error code:
-0&nbsp;means no errors;
-any other value means an error and stops <a href="#lua_dump"><code>lua_dump</code></a> from
-calling the writer again.
-
-
-
-
-
-<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>void lua_xmove (lua_State *from, lua_State *to, int n);</pre>
-
-<p>
-Exchange values between different threads of the <em>same</em> global state.
-
-
-<p>
-This function pops <code>n</code> values from the stack <code>from</code>,
-and pushes them onto the stack <code>to</code>.
-
-
-
-
-
-<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>int lua_yield  (lua_State *L, int nresults);</pre>
-
-<p>
-Yields a coroutine.
-
-
-<p>
-This function should only be called as the
-return expression of a C&nbsp;function, as follows:
-
-<pre>
-     return lua_yield (L, nresults);
-</pre><p>
-When a C&nbsp;function calls <a href="#lua_yield"><code>lua_yield</code></a> in that way,
-the running coroutine suspends its execution,
-and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
-The parameter <code>nresults</code> is the number of values from the stack
-that are passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.
-
-
-
-
-
-
-
-<h2>3.8 - <a name="3.8">The Debug Interface</a></h2>
-
-<p>
-Lua has no built-in debugging facilities.
-Instead, it offers a special interface
-by means of functions and <em>hooks</em>.
-This interface allows the construction of different
-kinds of debuggers, profilers, and other tools
-that need "inside information" from the interpreter.
-
-
-
-<hr><h3><a name="lua_Debug"><code>lua_Debug</code></a></h3>
-<pre>typedef struct lua_Debug {
-  int event;
-  const char *name;           /* (n) */
-  const char *namewhat;       /* (n) */
-  const char *what;           /* (S) */
-  const char *source;         /* (S) */
-  int currentline;            /* (l) */
-  int nups;                   /* (u) number of upvalues */
-  int linedefined;            /* (S) */
-  int lastlinedefined;        /* (S) */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  <em>other fields</em>
-} lua_Debug;</pre>
-
-<p>
-A structure used to carry different pieces of
-information about an active function.
-<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part
-of this structure, for later use.
-To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,
-call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-
-
-<p>
-The fields of <a href="#lua_Debug"><code>lua_Debug</code></a> have the following meaning:
-
-<ul>
-
-<li><b><code>source</code>:</b>
-If the function was defined in a string,
-then <code>source</code> is that string.
-If the function was defined in a file,
-then <code>source</code> starts with a '<code>@</code>' followed by the file name.
-</li>
-
-<li><b><code>short_src</code>:</b>
-a "printable" version of <code>source</code>, to be used in error messages.
-</li>
-
-<li><b><code>linedefined</code>:</b>
-the line number where the definition of the function starts.
-</li>
-
-<li><b><code>lastlinedefined</code>:</b>
-the line number where the definition of the function ends.
-</li>
-
-<li><b><code>what</code>:</b>
-the string <code>"Lua"</code> if the function is a Lua function,
-<code>"C"</code> if it is a C&nbsp;function,
-<code>"main"</code> if it is the main part of a chunk,
-and <code>"tail"</code> if it was a function that did a tail call.
-In the latter case,
-Lua has no other information about the function.
-</li>
-
-<li><b><code>currentline</code>:</b>
-the current line where the given function is executing.
-When no line information is available,
-<code>currentline</code> is set to -1.
-</li>
-
-<li><b><code>name</code>:</b>
-a reasonable name for the given function.
-Because functions in Lua are first-class values,
-they do not have a fixed name:
-some functions can be the value of multiple global variables,
-while others can be stored only in a table field.
-The <code>lua_getinfo</code> function checks how the function was
-called to find a suitable name.
-If it cannot find a name,
-then <code>name</code> is set to <code>NULL</code>.
-</li>
-
-<li><b><code>namewhat</code>:</b>
-explains the <code>name</code> field.
-The value of <code>namewhat</code> can be
-<code>"global"</code>, <code>"local"</code>, <code>"method"</code>,
-<code>"field"</code>, <code>"upvalue"</code>, or <code>""</code> (the empty string),
-according to how the function was called.
-(Lua uses the empty string when no other option seems to apply.)
-</li>
-
-<li><b><code>nups</code>:</b>
-the number of upvalues of the function.
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Hook lua_gethook (lua_State *L);</pre>
-
-<p>
-Returns the current hook function.
-
-
-
-
-
-<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_gethookcount (lua_State *L);</pre>
-
-<p>
-Returns the current hook count.
-
-
-
-
-
-<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_gethookmask (lua_State *L);</pre>
-
-<p>
-Returns the current hook mask.
-
-
-
-
-
-<hr><h3><a name="lua_getinfo"><code>lua_getinfo</code></a></h3><p>
-<span class="apii">[-(0|1), +(0|1|2), <em>m</em>]</span>
-<pre>int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);</pre>
-
-<p>
-Returns information about a specific function or function invocation.
-
-
-<p>
-To get information about a function invocation,
-the parameter <code>ar</code> must be a valid activation record that was
-filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
-given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
-
-
-<p>
-To get information about a function you push it onto the stack
-and start the <code>what</code> string with the character '<code>&gt;</code>'.
-(In that case,
-<code>lua_getinfo</code> pops the function in the top of the stack.)
-For instance, to know in which line a function <code>f</code> was defined,
-you can write the following code:
-
-<pre>
-     lua_Debug ar;
-     lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* get global 'f' */
-     lua_getinfo(L, "&gt;S", &amp;ar);
-     printf("%d\n", ar.linedefined);
-</pre>
-
-<p>
-Each character in the string <code>what</code>
-selects some fields of the structure <code>ar</code> to be filled or
-a value to be pushed on the stack:
-
-<ul>
-
-<li><b>'<code>n</code>':</b> fills in the field <code>name</code> and <code>namewhat</code>;
-</li>
-
-<li><b>'<code>S</code>':</b>
-fills in the fields <code>source</code>, <code>short_src</code>,
-<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>;
-</li>
-
-<li><b>'<code>l</code>':</b> fills in the field <code>currentline</code>;
-</li>
-
-<li><b>'<code>u</code>':</b> fills in the field <code>nups</code>;
-</li>
-
-<li><b>'<code>f</code>':</b>
-pushes onto the stack the function that is
-running at the given level;
-</li>
-
-<li><b>'<code>L</code>':</b>
-pushes onto the stack a table whose indices are the
-numbers of the lines that are valid on the function.
-(A <em>valid line</em> is a line with some associated code,
-that is, a line where you can put a break point.
-Non-valid lines include empty lines and comments.)
-</li>
-
-</ul>
-
-<p>
-This function returns 0 on error
-(for instance, an invalid option in <code>what</code>).
-
-
-
-
-
-<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);</pre>
-
-<p>
-Gets information about a local variable of a given activation record.
-The parameter <code>ar</code> must be a valid activation record that was
-filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
-given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
-The index <code>n</code> selects which local variable to inspect
-(1 is the first parameter or active local variable, and so on,
-until the last active local variable).
-<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
-and returns its name.
-
-
-<p>
-Variable names starting with '<code>(</code>' (open parentheses)
-represent internal variables
-(loop control variables, temporaries, and C&nbsp;function locals).
-
-
-<p>
-Returns <code>NULL</code> (and pushes nothing)
-when the index is greater than
-the number of active local variables.
-
-
-
-
-
-<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_getstack (lua_State *L, int level, lua_Debug *ar);</pre>
-
-<p>
-Get information about the interpreter runtime stack.
-
-
-<p>
-This function fills parts of a <a href="#lua_Debug"><code>lua_Debug</code></a> structure with
-an identification of the <em>activation record</em>
-of the function executing at a given level.
-Level&nbsp;0 is the current running function,
-whereas level <em>n+1</em> is the function that has called level <em>n</em>.
-When there are no errors, <a href="#lua_getstack"><code>lua_getstack</code></a> returns 1;
-when called with a level greater than the stack depth,
-it returns 0.
-
-
-
-
-
-<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>const char *lua_getupvalue (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Gets information about a closure's upvalue.
-(For Lua functions,
-upvalues are the external local variables that the function uses,
-and that are consequently included in its closure.)
-<a href="#lua_getupvalue"><code>lua_getupvalue</code></a> gets the index <code>n</code> of an upvalue,
-pushes the upvalue's value onto the stack,
-and returns its name.
-<code>funcindex</code> points to the closure in the stack.
-(Upvalues have no particular order,
-as they are active through the whole function.
-So, they are numbered in an arbitrary order.)
-
-
-<p>
-Returns <code>NULL</code> (and pushes nothing)
-when the index is greater than the number of upvalues.
-For C&nbsp;functions, this function uses the empty string <code>""</code>
-as a name for all upvalues.
-
-
-
-
-
-<hr><h3><a name="lua_Hook"><code>lua_Hook</code></a></h3>
-<pre>typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);</pre>
-
-<p>
-Type for debugging hook functions.
-
-
-<p>
-Whenever a hook is called, its <code>ar</code> argument has its field
-<code>event</code> set to the specific event that triggered the hook.
-Lua identifies these events with the following constants:
-<a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>,
-<a name="pdf-LUA_HOOKTAILRET"><code>LUA_HOOKTAILRET</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>,
-and <a name="pdf-LUA_HOOKCOUNT"><code>LUA_HOOKCOUNT</code></a>.
-Moreover, for line events, the field <code>currentline</code> is also set.
-To get the value of any other field in <code>ar</code>,
-the hook must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-For return events, <code>event</code> can be <code>LUA_HOOKRET</code>,
-the normal value, or <code>LUA_HOOKTAILRET</code>.
-In the latter case, Lua is simulating a return from
-a function that did a tail call;
-in this case, it is useless to call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-
-
-<p>
-While Lua is running a hook, it disables other calls to hooks.
-Therefore, if a hook calls back Lua to execute a function or a chunk,
-this execution occurs without any calls to hooks.
-
-
-
-
-
-<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
-
-<p>
-Sets the debugging hook function.
-
-
-<p>
-Argument <code>f</code> is the hook function.
-<code>mask</code> specifies on which events the hook will be called:
-it is formed by a bitwise or of the constants
-<a name="pdf-LUA_MASKCALL"><code>LUA_MASKCALL</code></a>,
-<a name="pdf-LUA_MASKRET"><code>LUA_MASKRET</code></a>,
-<a name="pdf-LUA_MASKLINE"><code>LUA_MASKLINE</code></a>,
-and <a name="pdf-LUA_MASKCOUNT"><code>LUA_MASKCOUNT</code></a>.
-The <code>count</code> argument is only meaningful when the mask
-includes <code>LUA_MASKCOUNT</code>.
-For each event, the hook is called as explained below:
-
-<ul>
-
-<li><b>The call hook:</b> is called when the interpreter calls a function.
-The hook is called just after Lua enters the new function,
-before the function gets its arguments.
-</li>
-
-<li><b>The return hook:</b> is called when the interpreter returns from a function.
-The hook is called just before Lua leaves the function.
-You have no access to the values to be returned by the function.
-</li>
-
-<li><b>The line hook:</b> is called when the interpreter is about to
-start the execution of a new line of code,
-or when it jumps back in the code (even to the same line).
-(This event only happens while Lua is executing a Lua function.)
-</li>
-
-<li><b>The count hook:</b> is called after the interpreter executes every
-<code>count</code> instructions.
-(This event only happens while Lua is executing a Lua function.)
-</li>
-
-</ul>
-
-<p>
-A hook is disabled by setting <code>mask</code> to zero.
-
-
-
-
-
-<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>
-<span class="apii">[-(0|1), +0, <em>-</em>]</span>
-<pre>const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);</pre>
-
-<p>
-Sets the value of a local variable of a given activation record.
-Parameters <code>ar</code> and <code>n</code> are as in <a href="#lua_getlocal"><code>lua_getlocal</code></a>
-(see <a href="#lua_getlocal"><code>lua_getlocal</code></a>).
-<a href="#lua_setlocal"><code>lua_setlocal</code></a> assigns the value at the top of the stack
-to the variable and returns its name.
-It also pops the value from the stack.
-
-
-<p>
-Returns <code>NULL</code> (and pops nothing)
-when the index is greater than
-the number of active local variables.
-
-
-
-
-
-<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>
-<span class="apii">[-(0|1), +0, <em>-</em>]</span>
-<pre>const char *lua_setupvalue (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Sets the value of a closure's upvalue.
-It assigns the value at the top of the stack
-to the upvalue and returns its name.
-It also pops the value from the stack.
-Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>
-(see <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>).
-
-
-<p>
-Returns <code>NULL</code> (and pops nothing)
-when the index is greater than the number of upvalues.
-
-
-
-
-
-
-
-<h1>4 - <a name="4">The Auxiliary Library</a></h1>
-
-<p>
-
-The <em>auxiliary library</em> provides several convenient functions
-to interface C with Lua.
-While the basic API provides the primitive functions for all
-interactions between C and Lua,
-the auxiliary library provides higher-level functions for some
-common tasks.
-
-
-<p>
-All functions from the auxiliary library
-are defined in header file <code>lauxlib.h</code> and
-have a prefix <code>luaL_</code>.
-
-
-<p>
-All functions in the auxiliary library are built on
-top of the basic API,
-and so they provide nothing that cannot be done with this API.
-
-
-<p>
-Several functions in the auxiliary library are used to
-check C&nbsp;function arguments.
-Their names are always <code>luaL_check*</code> or <code>luaL_opt*</code>.
-All of these functions throw an error if the check is not satisfied.
-Because the error message is formatted for arguments
-(e.g., "<code>bad argument #1</code>"),
-you should not use these functions for other stack values.
-
-
-
-<h2>4.1 - <a name="4.1">Functions and Types</a></h2>
-
-<p>
-Here we list all functions and types from the auxiliary library
-in alphabetical order.
-
-
-
-<hr><h3><a name="luaL_addchar"><code>luaL_addchar</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>
-
-<p>
-Adds the character <code>c</code> to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addlstring"><code>luaL_addlstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);</pre>
-
-<p>
-Adds the string pointed to by <code>s</code> with length <code>l</code> to
-the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-The string may contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="luaL_addsize"><code>luaL_addsize</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addsize (luaL_Buffer *B, size_t n);</pre>
-
-<p>
-Adds to the buffer <code>B</code> (see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>)
-a string of length <code>n</code> previously copied to the
-buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addstring"><code>luaL_addstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addstring (luaL_Buffer *B, const char *s);</pre>
-
-<p>
-Adds the zero-terminated string pointed to by <code>s</code>
-to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-The string may not contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>void luaL_addvalue (luaL_Buffer *B);</pre>
-
-<p>
-Adds the value at the top of the stack
-to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-Pops the value.
-
-
-<p>
-This is the only function on string buffers that can (and must)
-be called with an extra element on the stack,
-which is the value to be added to the buffer.
-
-
-
-
-
-<hr><h3><a name="luaL_argcheck"><code>luaL_argcheck</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_argcheck (lua_State *L,
-                    int cond,
-                    int narg,
-                    const char *extramsg);</pre>
-
-<p>
-Checks whether <code>cond</code> is true.
-If not, raises an error with the following message,
-where <code>func</code> is retrieved from the call stack:
-
-<pre>
-     bad argument #&lt;narg&gt; to &lt;func&gt; (&lt;extramsg&gt;)
-</pre>
-
-
-
-
-<hr><h3><a name="luaL_argerror"><code>luaL_argerror</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_argerror (lua_State *L, int narg, const char *extramsg);</pre>
-
-<p>
-Raises an error with the following message,
-where <code>func</code> is retrieved from the call stack:
-
-<pre>
-     bad argument #&lt;narg&gt; to &lt;func&gt; (&lt;extramsg&gt;)
-</pre>
-
-<p>
-This function never returns,
-but it is an idiom to use it in C&nbsp;functions
-as <code>return luaL_argerror(<em>args</em>)</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_Buffer"><code>luaL_Buffer</code></a></h3>
-<pre>typedef struct luaL_Buffer luaL_Buffer;</pre>
-
-<p>
-Type for a <em>string buffer</em>.
-
-
-<p>
-A string buffer allows C&nbsp;code to build Lua strings piecemeal.
-Its pattern of use is as follows:
-
-<ul>
-
-<li>First you declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
-
-<li>Then you initialize it with a call <code>luaL_buffinit(L, &amp;b)</code>.</li>
-
-<li>
-Then you add string pieces to the buffer calling any of
-the <code>luaL_add*</code> functions.
-</li>
-
-<li>
-You finish by calling <code>luaL_pushresult(&amp;b)</code>.
-This call leaves the final string on the top of the stack.
-</li>
-
-</ul>
-
-<p>
-During its normal operation,
-a string buffer uses a variable number of stack slots.
-So, while using a buffer, you cannot assume that you know where
-the top of the stack is.
-You can use the stack between successive calls to buffer operations
-as long as that use is balanced;
-that is,
-when you call a buffer operation,
-the stack is at the same level
-it was immediately after the previous buffer operation.
-(The only exception to this rule is <a href="#luaL_addvalue"><code>luaL_addvalue</code></a>.)
-After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a> the stack is back to its
-level when the buffer was initialized,
-plus the final string on its top.
-
-
-
-
-
-<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void luaL_buffinit (lua_State *L, luaL_Buffer *B);</pre>
-
-<p>
-Initializes a buffer <code>B</code>.
-This function does not allocate any space;
-the buffer must be declared as a variable
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_callmeta"><code>luaL_callmeta</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>e</em>]</span>
-<pre>int luaL_callmeta (lua_State *L, int obj, const char *e);</pre>
-
-<p>
-Calls a metamethod.
-
-
-<p>
-If the object at index <code>obj</code> has a metatable and this
-metatable has a field <code>e</code>,
-this function calls this field and passes the object as its only argument.
-In this case this function returns 1 and pushes onto the
-stack the value returned by the call.
-If there is no metatable or no metamethod,
-this function returns 0 (without pushing any value on the stack).
-
-
-
-
-
-<hr><h3><a name="luaL_checkany"><code>luaL_checkany</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkany (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function has an argument
-of any type (including <b>nil</b>) at position <code>narg</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkint"><code>luaL_checkint</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_checkint (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number cast to an <code>int</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkinteger"><code>luaL_checkinteger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Integer luaL_checkinteger (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_checklong"><code>luaL_checklong</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>long luaL_checklong (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number cast to a <code>long</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checklstring"><code>luaL_checklstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_checklstring (lua_State *L, int narg, size_t *l);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a string
-and returns this string;
-if <code>l</code> is not <code>NULL</code> fills <code>*l</code>
-with the string's length.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_checknumber"><code>luaL_checknumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Number luaL_checknumber (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number.
-
-
-
-
-
-<hr><h3><a name="luaL_checkoption"><code>luaL_checkoption</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_checkoption (lua_State *L,
-                      int narg,
-                      const char *def,
-                      const char *const lst[]);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a string and
-searches for this string in the array <code>lst</code>
-(which must be NULL-terminated).
-Returns the index in the array where the string was found.
-Raises an error if the argument is not a string or
-if the string cannot be found.
-
-
-<p>
-If <code>def</code> is not <code>NULL</code>,
-the function uses <code>def</code> as a default value when
-there is no argument <code>narg</code> or if this argument is <b>nil</b>.
-
-
-<p>
-This is a useful function for mapping strings to C&nbsp;enums.
-(The usual convention in Lua libraries is
-to use strings instead of numbers to select options.)
-
-
-
-
-
-<hr><h3><a name="luaL_checkstack"><code>luaL_checkstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkstack (lua_State *L, int sz, const char *msg);</pre>
-
-<p>
-Grows the stack size to <code>top + sz</code> elements,
-raising an error if the stack cannot grow to that size.
-<code>msg</code> is an additional text to go into the error message.
-
-
-
-
-
-<hr><h3><a name="luaL_checkstring"><code>luaL_checkstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_checkstring (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a string
-and returns this string.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_checktype"><code>luaL_checktype</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checktype (lua_State *L, int narg, int t);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> has type <code>t</code>.
-See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkudata"><code>luaL_checkudata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void *luaL_checkudata (lua_State *L, int narg, const char *tname);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a userdata
-of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_dofile"><code>luaL_dofile</code></a></h3><p>
-<span class="apii">[-0, +?, <em>m</em>]</span>
-<pre>int luaL_dofile (lua_State *L, const char *filename);</pre>
-
-<p>
-Loads and runs the given file.
-It is defined as the following macro:
-
-<pre>
-     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
-</pre><p>
-It returns 0 if there are no errors
-or 1 in case of errors.
-
-
-
-
-
-<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>
-<span class="apii">[-0, +?, <em>m</em>]</span>
-<pre>int luaL_dostring (lua_State *L, const char *str);</pre>
-
-<p>
-Loads and runs the given string.
-It is defined as the following macro:
-
-<pre>
-     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
-</pre><p>
-It returns 0 if there are no errors
-or 1 in case of errors.
-
-
-
-
-
-<hr><h3><a name="luaL_error"><code>luaL_error</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_error (lua_State *L, const char *fmt, ...);</pre>
-
-<p>
-Raises an error.
-The error message format is given by <code>fmt</code>
-plus any extra arguments,
-following the same rules of <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>.
-It also adds at the beginning of the message the file name and
-the line number where the error occurred,
-if this information is available.
-
-
-<p>
-This function never returns,
-but it is an idiom to use it in C&nbsp;functions
-as <code>return luaL_error(<em>args</em>)</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_getmetafield"><code>luaL_getmetafield</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>m</em>]</span>
-<pre>int luaL_getmetafield (lua_State *L, int obj, const char *e);</pre>
-
-<p>
-Pushes onto the stack the field <code>e</code> from the metatable
-of the object at index <code>obj</code>.
-If the object does not have a metatable,
-or if the metatable does not have this field,
-returns 0 and pushes nothing.
-
-
-
-
-
-<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void luaL_getmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-Pushes onto the stack the metatable associated with name <code>tname</code>
-in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *luaL_gsub (lua_State *L,
-                       const char *s,
-                       const char *p,
-                       const char *r);</pre>
-
-<p>
-Creates a copy of string <code>s</code> by replacing
-any occurrence of the string <code>p</code>
-with the string <code>r</code>.
-Pushes the resulting string on the stack and returns it.
-
-
-
-
-
-<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadbuffer (lua_State *L,
-                     const char *buff,
-                     size_t sz,
-                     const char *name);</pre>
-
-<p>
-Loads a buffer as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the
-buffer pointed to by <code>buff</code> with size <code>sz</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
-<code>name</code> is the chunk name,
-used for debug information and error messages.
-
-
-
-
-
-<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadfile (lua_State *L, const char *filename);</pre>
-
-<p>
-Loads a file as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file
-named <code>filename</code>.
-If <code>filename</code> is <code>NULL</code>,
-then it loads from the standard input.
-The first line in the file is ignored if it starts with a <code>#</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>,
-but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>
-if it cannot open/read the file.
-
-
-<p>
-As <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
-it does not run it.
-
-
-
-
-
-<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadstring (lua_State *L, const char *s);</pre>
-
-<p>
-Loads a string as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in
-the zero-terminated string <code>s</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
-
-
-<p>
-Also as <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
-it does not run it.
-
-
-
-
-
-<hr><h3><a name="luaL_newmetatable"><code>luaL_newmetatable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_newmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-If the registry already has the key <code>tname</code>,
-returns 0.
-Otherwise,
-creates a new table to be used as a metatable for userdata,
-adds it to the registry with key <code>tname</code>,
-and returns 1.
-
-
-<p>
-In both cases pushes onto the stack the final value associated
-with <code>tname</code> in the registry.
-
-
-
-
-
-<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_State *luaL_newstate (void);</pre>
-
-<p>
-Creates a new Lua state.
-It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an
-allocator based on the standard&nbsp;C <code>realloc</code> function
-and then sets a panic function (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>) that prints
-an error message to the standard error output in case of fatal
-errors.
-
-
-<p>
-Returns the new state,
-or <code>NULL</code> if there is a memory allocation error.
-
-
-
-
-
-<hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_openlibs (lua_State *L);</pre>
-
-<p>
-Opens all standard Lua libraries into the given state.
-
-
-
-
-
-<hr><h3><a name="luaL_optint"><code>luaL_optint</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_optint (lua_State *L, int narg, int d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number cast to an <code>int</code>.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optinteger"><code>luaL_optinteger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Integer luaL_optinteger (lua_State *L,
-                             int narg,
-                             lua_Integer d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optlong"><code>luaL_optlong</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>long luaL_optlong (lua_State *L, int narg, long d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number cast to a <code>long</code>.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optlstring"><code>luaL_optlstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_optlstring (lua_State *L,
-                             int narg,
-                             const char *d,
-                             size_t *l);</pre>
-
-<p>
-If the function argument <code>narg</code> is a string,
-returns this string.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-<p>
-If <code>l</code> is not <code>NULL</code>,
-fills the position <code>*l</code> with the results's length.
-
-
-
-
-
-<hr><h3><a name="luaL_optnumber"><code>luaL_optnumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optstring"><code>luaL_optstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_optstring (lua_State *L,
-                            int narg,
-                            const char *d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a string,
-returns this string.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>char *luaL_prepbuffer (luaL_Buffer *B);</pre>
-
-<p>
-Returns an address to a space of size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>
-where you can copy a string to be added to buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-After copying the string into this space you must call
-<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add
-it to the buffer.
-
-
-
-
-
-<hr><h3><a name="luaL_pushresult"><code>luaL_pushresult</code></a></h3><p>
-<span class="apii">[-?, +1, <em>m</em>]</span>
-<pre>void luaL_pushresult (luaL_Buffer *B);</pre>
-
-<p>
-Finishes the use of buffer <code>B</code> leaving the final string on
-the top of the stack.
-
-
-
-
-
-<hr><h3><a name="luaL_ref"><code>luaL_ref</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>int luaL_ref (lua_State *L, int t);</pre>
-
-<p>
-Creates and returns a <em>reference</em>,
-in the table at index <code>t</code>,
-for the object at the top of the stack (and pops the object).
-
-
-<p>
-A reference is a unique integer key.
-As long as you do not manually add integer keys into table <code>t</code>,
-<a href="#luaL_ref"><code>luaL_ref</code></a> ensures the uniqueness of the key it returns.
-You can retrieve an object referred by reference <code>r</code>
-by calling <code>lua_rawgeti(L, t, r)</code>.
-Function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference and its associated object.
-
-
-<p>
-If the object at the top of the stack is <b>nil</b>,
-<a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>.
-The constant <a name="pdf-LUA_NOREF"><code>LUA_NOREF</code></a> is guaranteed to be different
-from any reference returned by <a href="#luaL_ref"><code>luaL_ref</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_Reg"><code>luaL_Reg</code></a></h3>
-<pre>typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;</pre>
-
-<p>
-Type for arrays of functions to be registered by
-<a href="#luaL_register"><code>luaL_register</code></a>.
-<code>name</code> is the function name and <code>func</code> is a pointer to
-the function.
-Any array of <a href="#luaL_Reg"><code>luaL_Reg</code></a> must end with an sentinel entry
-in which both <code>name</code> and <code>func</code> are <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_register"><code>luaL_register</code></a></h3><p>
-<span class="apii">[-(0|1), +1, <em>m</em>]</span>
-<pre>void luaL_register (lua_State *L,
-                    const char *libname,
-                    const luaL_Reg *l);</pre>
-
-<p>
-Opens a library.
-
-
-<p>
-When called with <code>libname</code> equal to <code>NULL</code>,
-it simply registers all functions in the list <code>l</code>
-(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack.
-
-
-<p>
-When called with a non-null <code>libname</code>,
-<code>luaL_register</code> creates a new table <code>t</code>,
-sets it as the value of the global variable <code>libname</code>,
-sets it as the value of <code>package.loaded[libname]</code>,
-and registers on it all functions in the list <code>l</code>.
-If there is a table in <code>package.loaded[libname]</code> or in
-variable <code>libname</code>,
-reuses this table instead of creating a new one.
-
-
-<p>
-In any case the function leaves the table
-on the top of the stack.
-
-
-
-
-
-<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>const char *luaL_typename (lua_State *L, int index);</pre>
-
-<p>
-Returns the name of the type of the value at the given index.
-
-
-
-
-
-<hr><h3><a name="luaL_typerror"><code>luaL_typerror</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_typerror (lua_State *L, int narg, const char *tname);</pre>
-
-<p>
-Generates an error with a message like the following:
-
-<pre>
-     <em>location</em>: bad argument <em>narg</em> to '<em>func</em>' (<em>tname</em> expected, got <em>rt</em>)
-</pre><p>
-where <code><em>location</em></code> is produced by <a href="#luaL_where"><code>luaL_where</code></a>,
-<code><em>func</em></code> is the name of the current function,
-and <code><em>rt</em></code> is the type name of the actual argument.
-
-
-
-
-
-<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
-
-<p>
-Releases reference <code>ref</code> from the table at index <code>t</code>
-(see <a href="#luaL_ref"><code>luaL_ref</code></a>).
-The entry is removed from the table,
-so that the referred object can be collected.
-The reference <code>ref</code> is also freed to be used again.
-
-
-<p>
-If <code>ref</code> is <a href="#pdf-LUA_NOREF"><code>LUA_NOREF</code></a> or <a href="#pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>,
-<a href="#luaL_unref"><code>luaL_unref</code></a> does nothing.
-
-
-
-
-
-<hr><h3><a name="luaL_where"><code>luaL_where</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void luaL_where (lua_State *L, int lvl);</pre>
-
-<p>
-Pushes onto the stack a string identifying the current position
-of the control at level <code>lvl</code> in the call stack.
-Typically this string has the following format:
-
-<pre>
-     <em>chunkname</em>:<em>currentline</em>:
-</pre><p>
-Level&nbsp;0 is the running function,
-level&nbsp;1 is the function that called the running function,
-etc.
-
-
-<p>
-This function is used to build a prefix for error messages.
-
-
-
-
-
-
-
-<h1>5 - <a name="5">Standard Libraries</a></h1>
-
-<p>
-The standard Lua libraries provide useful functions
-that are implemented directly through the C&nbsp;API.
-Some of these functions provide essential services to the language
-(e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>);
-others provide access to "outside" services (e.g., I/O);
-and others could be implemented in Lua itself,
-but are quite useful or have critical performance requirements that
-deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>).
-
-
-<p>
-All libraries are implemented through the official C&nbsp;API
-and are provided as separate C&nbsp;modules.
-Currently, Lua has the following standard libraries:
-
-<ul>
-
-<li>basic library,</li> which includes the coroutine sub-library;
-
-<li>package library;</li>
-
-<li>string manipulation;</li>
-
-<li>table manipulation;</li>
-
-<li>mathematical functions (sin, log, etc.);</li>
-
-<li>input and output;</li>
-
-<li>operating system facilities;</li>
-
-<li>debug facilities.</li>
-
-</ul><p>
-Except for the basic and package libraries,
-each library provides all its functions as fields of a global table
-or as methods of its objects.
-
-
-<p>
-To have access to these libraries,
-the C&nbsp;host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function,
-which opens all standard libraries.
-Alternatively,
-it can open them individually by calling
-<a name="pdf-luaopen_base"><code>luaopen_base</code></a> (for the basic library),
-<a name="pdf-luaopen_package"><code>luaopen_package</code></a> (for the package library),
-<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),
-<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),
-<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),
-<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),
-<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the Operating System library),
-and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).
-These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>
-and should not be called directly:
-you must call them like any other Lua C&nbsp;function,
-e.g., by using <a href="#lua_call"><code>lua_call</code></a>.
-
-
-
-<h2>5.1 - <a name="5.1">Basic Functions</a></h2>
-
-<p>
-The basic library provides some core functions to Lua.
-If you do not include this library in your application,
-you should check carefully whether you need to provide
-implementations for some of its facilities.
-
-
-<p>
-<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>
-Issues an  error when
-the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);
-otherwise, returns all its arguments.
-<code>message</code> is an error message;
-when absent, it defaults to "assertion failed!"
-
-
-
-
-<p>
-<hr><h3><a name="pdf-collectgarbage"><code>collectgarbage (opt [, arg])</code></a></h3>
-
-
-<p>
-This function is a generic interface to the garbage collector.
-It performs different functions according to its first argument, <code>opt</code>:
-
-<ul>
-
-<li><b>"stop":</b>
-stops the garbage collector.
-</li>
-
-<li><b>"restart":</b>
-restarts the garbage collector.
-</li>
-
-<li><b>"collect":</b>
-performs a full garbage-collection cycle.
-</li>
-
-<li><b>"count":</b>
-returns the total memory in use by Lua (in Kbytes).
-</li>
-
-<li><b>"step":</b>
-performs a garbage-collection step.
-The step "size" is controlled by <code>arg</code>
-(larger values mean more steps) in a non-specified way.
-If you want to control the step size
-you must experimentally tune the value of <code>arg</code>.
-Returns <b>true</b> if the step finished a collection cycle.
-</li>
-
-<li><b>"setpause":</b>
-sets <code>arg</code> as the new value for the <em>pause</em> of
-the collector (see <a href="#2.10">&sect;2.10</a>).
-Returns the previous value for <em>pause</em>.
-</li>
-
-<li><b>"setstepmul":</b>
-sets <code>arg</code> as the new value for the <em>step multiplier</em> of
-the collector (see <a href="#2.10">&sect;2.10</a>).
-Returns the previous value for <em>step</em>.
-</li>
-
-</ul>
-
-
-
-<p>
-<hr><h3><a name="pdf-dofile"><code>dofile (filename)</code></a></h3>
-Opens the named file and executes its contents as a Lua chunk.
-When called without arguments,
-<code>dofile</code> executes the contents of the standard input (<code>stdin</code>).
-Returns all values returned by the chunk.
-In case of errors, <code>dofile</code> propagates the error
-to its caller (that is, <code>dofile</code> does not run in protected mode).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>
-Terminates the last protected function called
-and returns <code>message</code> as the error message.
-Function <code>error</code> never returns.
-
-
-<p>
-Usually, <code>error</code> adds some information about the error position
-at the beginning of the message.
-The <code>level</code> argument specifies how to get the error position.
-With level&nbsp;1 (the default), the error position is where the
-<code>error</code> function was called.
-Level&nbsp;2 points the error to where the function
-that called <code>error</code> was called; and so on.
-Passing a level&nbsp;0 avoids the addition of error position information
-to the message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-_G"><code>_G</code></a></h3>
-A global variable (not a function) that
-holds the global environment (that is, <code>_G._G = _G</code>).
-Lua itself does not use this variable;
-changing its value does not affect any environment,
-nor vice-versa.
-(Use <a href="#pdf-setfenv"><code>setfenv</code></a> to change environments.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-getfenv"><code>getfenv ([f])</code></a></h3>
-Returns the current environment in use by the function.
-<code>f</code> can be a Lua function or a number
-that specifies the function at that stack level:
-Level&nbsp;1 is the function calling <code>getfenv</code>.
-If the given function is not a Lua function,
-or if <code>f</code> is 0,
-<code>getfenv</code> returns the global environment.
-The default for <code>f</code> is 1.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-getmetatable"><code>getmetatable (object)</code></a></h3>
-
-
-<p>
-If <code>object</code> does not have a metatable, returns <b>nil</b>.
-Otherwise,
-if the object's metatable has a <code>"__metatable"</code> field,
-returns the associated value.
-Otherwise, returns the metatable of the given object.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-ipairs"><code>ipairs (t)</code></a></h3>
-
-
-<p>
-Returns three values: an iterator function, the table <code>t</code>, and 0,
-so that the construction
-
-<pre>
-     for i,v in ipairs(t) do <em>body</em> end
-</pre><p>
-will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), &middot;&middot;&middot;,
-up to the first integer key absent from the table.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-load"><code>load (func [, chunkname])</code></a></h3>
-
-
-<p>
-Loads a chunk using function <code>func</code> to get its pieces.
-Each call to <code>func</code> must return a string that concatenates
-with previous results.
-A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.
-
-
-<p>
-If there are no errors,
-returns the compiled chunk as a function;
-otherwise, returns <b>nil</b> plus the error message.
-The environment of the returned function is the global environment.
-
-
-<p>
-<code>chunkname</code> is used as the chunk name for error messages
-and debug information.
-When absent,
-it defaults to "<code>=(load)</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-load"><code>load</code></a>,
-but gets the chunk from file <code>filename</code>
-or from the standard input,
-if no file name is given.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-loadstring"><code>loadstring (string [, chunkname])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-load"><code>load</code></a>,
-but gets the chunk from the given string.
-
-
-<p>
-To load and run a given string, use the idiom
-
-<pre>
-     assert(loadstring(s))()
-</pre>
-
-<p>
-When absent,
-<code>chunkname</code> defaults to the given string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>
-
-
-<p>
-Allows a program to traverse all fields of a table.
-Its first argument is a table and its second argument
-is an index in this table.
-<code>next</code> returns the next index of the table
-and its associated value.
-When called with <b>nil</b> as its second argument,
-<code>next</code> returns an initial index
-and its associated value.
-When called with the last index,
-or with <b>nil</b> in an empty table,
-<code>next</code> returns <b>nil</b>.
-If the second argument is absent, then it is interpreted as <b>nil</b>.
-In particular,
-you can use <code>next(t)</code> to check whether a table is empty.
-
-
-<p>
-The order in which the indices are enumerated is not specified,
-<em>even for numeric indices</em>.
-(To traverse a table in numeric order,
-use a numerical <b>for</b> or the <a href="#pdf-ipairs"><code>ipairs</code></a> function.)
-
-
-<p>
-The behavior of <code>next</code> is <em>undefined</em> if,
-during the traversal,
-you assign any value to a non-existent field in the table.
-You may however modify existing fields.
-In particular, you may clear existing fields.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-pairs"><code>pairs (t)</code></a></h3>
-
-
-<p>
-Returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>,
-so that the construction
-
-<pre>
-     for k,v in pairs(t) do <em>body</em> end
-</pre><p>
-will iterate over all key&ndash;value pairs of table <code>t</code>.
-
-
-<p>
-See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
-the table during its traversal.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-pcall"><code>pcall (f, arg1, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Calls function <code>f</code> with
-the given arguments in <em>protected mode</em>.
-This means that any error inside&nbsp;<code>f</code> is not propagated;
-instead, <code>pcall</code> catches the error
-and returns a status code.
-Its first result is the status code (a boolean),
-which is true if the call succeeds without errors.
-In such case, <code>pcall</code> also returns all results from the call,
-after this first result.
-In case of any error, <code>pcall</code> returns <b>false</b> plus the error message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-print"><code>print (&middot;&middot;&middot;)</code></a></h3>
-Receives any number of arguments,
-and prints their values to <code>stdout</code>,
-using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert them to strings.
-<code>print</code> is not intended for formatted output,
-but only as a quick way to show a value,
-typically for debugging.
-For formatted output, use <a href="#pdf-string.format"><code>string.format</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawequal"><code>rawequal (v1, v2)</code></a></h3>
-Checks whether <code>v1</code> is equal to <code>v2</code>,
-without invoking any metamethod.
-Returns a boolean.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawget"><code>rawget (table, index)</code></a></h3>
-Gets the real value of <code>table[index]</code>,
-without invoking any metamethod.
-<code>table</code> must be a table;
-<code>index</code> may be any value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>
-Sets the real value of <code>table[index]</code> to <code>value</code>,
-without invoking any metamethod.
-<code>table</code> must be a table,
-<code>index</code> any value different from <b>nil</b>,
-and <code>value</code> any Lua value.
-
-
-<p>
-This function returns <code>table</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-select"><code>select (index, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-If <code>index</code> is a number,
-returns all arguments after argument number <code>index</code>.
-Otherwise, <code>index</code> must be the string <code>"#"</code>,
-and <code>select</code> returns the total number of extra arguments it received.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-setfenv"><code>setfenv (f, table)</code></a></h3>
-
-
-<p>
-Sets the environment to be used by the given function.
-<code>f</code> can be a Lua function or a number
-that specifies the function at that stack level:
-Level&nbsp;1 is the function calling <code>setfenv</code>.
-<code>setfenv</code> returns the given function.
-
-
-<p>
-As a special case, when <code>f</code> is 0 <code>setfenv</code> changes
-the environment of the running thread.
-In this case, <code>setfenv</code> returns no values.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-setmetatable"><code>setmetatable (table, metatable)</code></a></h3>
-
-
-<p>
-Sets the metatable for the given table.
-(You cannot change the metatable of other types from Lua, only from&nbsp;C.)
-If <code>metatable</code> is <b>nil</b>,
-removes the metatable of the given table.
-If the original metatable has a <code>"__metatable"</code> field,
-raises an error.
-
-
-<p>
-This function returns <code>table</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>
-Tries to convert its argument to a number.
-If the argument is already a number or a string convertible
-to a number, then <code>tonumber</code> returns this number;
-otherwise, it returns <b>nil</b>.
-
-
-<p>
-An optional argument specifies the base to interpret the numeral.
-The base may be any integer between 2 and 36, inclusive.
-In bases above&nbsp;10, the letter '<code>A</code>' (in either upper or lower case)
-represents&nbsp;10, '<code>B</code>' represents&nbsp;11, and so forth,
-with '<code>Z</code>' representing 35.
-In base 10 (the default), the number can have a decimal part,
-as well as an optional exponent part (see <a href="#2.1">&sect;2.1</a>).
-In other bases, only unsigned integers are accepted.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-tostring"><code>tostring (e)</code></a></h3>
-Receives an argument of any type and
-converts it to a string in a reasonable format.
-For complete control of how numbers are converted,
-use <a href="#pdf-string.format"><code>string.format</code></a>.
-
-
-<p>
-If the metatable of <code>e</code> has a <code>"__tostring"</code> field,
-then <code>tostring</code> calls the corresponding value
-with <code>e</code> as argument,
-and uses the result of the call as its result.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-type"><code>type (v)</code></a></h3>
-Returns the type of its only argument, coded as a string.
-The possible results of this function are
-"<code>nil</code>" (a string, not the value <b>nil</b>),
-"<code>number</code>",
-"<code>string</code>",
-"<code>boolean</code>",
-"<code>table</code>",
-"<code>function</code>",
-"<code>thread</code>",
-and "<code>userdata</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-unpack"><code>unpack (list [, i [, j]])</code></a></h3>
-Returns the elements from the given table.
-This function is equivalent to
-
-<pre>
-     return list[i], list[i+1], &middot;&middot;&middot;, list[j]
-</pre><p>
-except that the above code can be written only for a fixed number
-of elements.
-By default, <code>i</code> is&nbsp;1 and <code>j</code> is the length of the list,
-as defined by the length operator (see <a href="#2.5.5">&sect;2.5.5</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>
-A global variable (not a function) that
-holds a string containing the current interpreter version.
-The current contents of this variable is "<code>Lua 5.1</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-xpcall"><code>xpcall (f, err)</code></a></h3>
-
-
-<p>
-This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,
-except that you can set a new error handler.
-
-
-<p>
-<code>xpcall</code> calls function <code>f</code> in protected mode,
-using <code>err</code> as the error handler.
-Any error inside <code>f</code> is not propagated;
-instead, <code>xpcall</code> catches the error,
-calls the <code>err</code> function with the original error object,
-and returns a status code.
-Its first result is the status code (a boolean),
-which is true if the call succeeds without errors.
-In this case, <code>xpcall</code> also returns all results from the call,
-after this first result.
-In case of any error,
-<code>xpcall</code> returns <b>false</b> plus the result from <code>err</code>.
-
-
-
-
-
-
-
-<h2>5.2 - <a name="5.2">Coroutine Manipulation</a></h2>
-
-<p>
-The operations related to coroutines comprise a sub-library of
-the basic library and come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>.
-See <a href="#2.11">&sect;2.11</a> for a general description of coroutines.
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.create"><code>coroutine.create (f)</code></a></h3>
-
-
-<p>
-Creates a new coroutine, with body <code>f</code>.
-<code>f</code> must be a Lua function.
-Returns this new coroutine,
-an object with type <code>"thread"</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Starts or continues the execution of coroutine <code>co</code>.
-The first time you resume a coroutine,
-it starts running its body.
-The values <code>val1</code>, &middot;&middot;&middot; are passed
-as the arguments to the body function.
-If the coroutine has yielded,
-<code>resume</code> restarts it;
-the values <code>val1</code>, &middot;&middot;&middot; are passed
-as the results from the yield.
-
-
-<p>
-If the coroutine runs without any errors,
-<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>
-(if the coroutine yields) or any values returned by the body function
-(if the coroutine terminates).
-If there is any error,
-<code>resume</code> returns <b>false</b> plus the error message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.running"><code>coroutine.running ()</code></a></h3>
-
-
-<p>
-Returns the running coroutine,
-or <b>nil</b> when called by the main thread.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.status"><code>coroutine.status (co)</code></a></h3>
-
-
-<p>
-Returns the status of coroutine <code>co</code>, as a string:
-<code>"running"</code>,
-if the coroutine is running (that is, it called <code>status</code>);
-<code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>,
-or if it has not started running yet;
-<code>"normal"</code> if the coroutine is active but not running
-(that is, it has resumed another coroutine);
-and <code>"dead"</code> if the coroutine has finished its body function,
-or if it has stopped with an error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.wrap"><code>coroutine.wrap (f)</code></a></h3>
-
-
-<p>
-Creates a new coroutine, with body <code>f</code>.
-<code>f</code> must be a Lua function.
-Returns a function that resumes the coroutine each time it is called.
-Any arguments passed to the function behave as the
-extra arguments to <code>resume</code>.
-Returns the same values returned by <code>resume</code>,
-except the first boolean.
-In case of error, propagates the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Suspends the execution of the calling coroutine.
-The coroutine cannot be running a C&nbsp;function,
-a metamethod, or an iterator.
-Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>.
-
-
-
-
-
-
-
-<h2>5.3 - <a name="5.3">Modules</a></h2>
-
-<p>
-The package library provides basic
-facilities for loading and building modules in Lua.
-It exports two of its functions directly in the global environment:
-<a href="#pdf-require"><code>require</code></a> and <a href="#pdf-module"><code>module</code></a>.
-Everything else is exported in a table <a name="pdf-package"><code>package</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-module"><code>module (name [, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Creates a module.
-If there is a table in <code>package.loaded[name]</code>,
-this table is the module.
-Otherwise, if there is a global table <code>t</code> with the given name,
-this table is the module.
-Otherwise creates a new table <code>t</code> and
-sets it as the value of the global <code>name</code> and
-the value of <code>package.loaded[name]</code>.
-This function also initializes <code>t._NAME</code> with the given name,
-<code>t._M</code> with the module (<code>t</code> itself),
-and <code>t._PACKAGE</code> with the package name
-(the full module name minus last component; see below).
-Finally, <code>module</code> sets <code>t</code> as the new environment
-of the current function and the new value of <code>package.loaded[name]</code>,
-so that <a href="#pdf-require"><code>require</code></a> returns <code>t</code>.
-
-
-<p>
-If <code>name</code> is a compound name
-(that is, one with components separated by dots),
-<code>module</code> creates (or reuses, if they already exist)
-tables for each component.
-For instance, if <code>name</code> is <code>a.b.c</code>,
-then <code>module</code> stores the module table in field <code>c</code> of
-field <code>b</code> of global <code>a</code>.
-
-
-<p>
-This function can receive optional <em>options</em> after
-the module name,
-where each option is a function to be applied over the module.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-require"><code>require (modname)</code></a></h3>
-
-
-<p>
-Loads the given module.
-The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table
-to determine whether <code>modname</code> is already loaded.
-If it is, then <code>require</code> returns the value stored
-at <code>package.loaded[modname]</code>.
-Otherwise, it tries to find a <em>loader</em> for the module.
-
-
-<p>
-To find a loader,
-<code>require</code> is guided by the <a href="#pdf-package.loaders"><code>package.loaders</code></a> array.
-By changing this array,
-we can change how <code>require</code> looks for a module.
-The following explanation is based on the default configuration
-for <a href="#pdf-package.loaders"><code>package.loaders</code></a>.
-
-
-<p>
-First <code>require</code> queries <code>package.preload[modname]</code>.
-If it has a value,
-this value (which should be a function) is the loader.
-Otherwise <code>require</code> searches for a Lua loader using the
-path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
-If that also fails, it searches for a C&nbsp;loader using the
-path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
-If that also fails,
-it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.loaders"><code>package.loaders</code></a>).
-
-
-<p>
-Once a loader is found,
-<code>require</code> calls the loader with a single argument, <code>modname</code>.
-If the loader returns any value,
-<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.
-If the loader returns no value and
-has not assigned any value to <code>package.loaded[modname]</code>,
-then <code>require</code> assigns <b>true</b> to this entry.
-In any case, <code>require</code> returns the
-final value of <code>package.loaded[modname]</code>.
-
-
-<p>
-If there is any error loading or running the module,
-or if it cannot find any loader for the module,
-then <code>require</code> signals an error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.cpath"><code>package.cpath</code></a></h3>
-
-
-<p>
-The path used by <a href="#pdf-require"><code>require</code></a> to search for a C&nbsp;loader.
-
-
-<p>
-Lua initializes the C&nbsp;path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
-it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,
-using the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>
-or a default path defined in <code>luaconf.h</code>.
-
-
-
-
-<p>
-
-<hr><h3><a name="pdf-package.loaded"><code>package.loaded</code></a></h3>
-
-
-<p>
-A table used by <a href="#pdf-require"><code>require</code></a> to control which
-modules are already loaded.
-When you require a module <code>modname</code> and
-<code>package.loaded[modname]</code> is not false,
-<a href="#pdf-require"><code>require</code></a> simply returns the value stored there.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.loaders"><code>package.loaders</code></a></h3>
-
-
-<p>
-A table used by <a href="#pdf-require"><code>require</code></a> to control how to load modules.
-
-
-<p>
-Each entry in this table is a <em>searcher function</em>.
-When looking for a module,
-<a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
-with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
-sole parameter.
-The function can return another function (the module <em>loader</em>)
-or a string explaining why it did not find that module
-(or <b>nil</b> if it has nothing to say).
-Lua initializes this table with four functions.
-
-
-<p>
-The first searcher simply looks for a loader in the
-<a href="#pdf-package.preload"><code>package.preload</code></a> table.
-
-
-<p>
-The second searcher looks for a loader as a Lua library,
-using the path stored at <a href="#pdf-package.path"><code>package.path</code></a>.
-A path is a sequence of <em>templates</em> separated by semicolons.
-For each template,
-the searcher will change each interrogation
-mark in the template by <code>filename</code>,
-which is the module name with each dot replaced by a
-"directory separator" (such as "<code>/</code>" in Unix);
-then it will try to open the resulting file name.
-So, for instance, if the Lua path is the string
-
-<pre>
-     "./?.lua;./?.lc;/usr/local/?/init.lua"
-</pre><p>
-the search for a Lua file for module <code>foo</code>
-will try to open the files
-<code>./foo.lua</code>, <code>./foo.lc</code>, and
-<code>/usr/local/foo/init.lua</code>, in that order.
-
-
-<p>
-The third searcher looks for a loader as a C&nbsp;library,
-using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
-For instance,
-if the C&nbsp;path is the string
-
-<pre>
-     "./?.so;./?.dll;/usr/local/?/init.so"
-</pre><p>
-the searcher for module <code>foo</code>
-will try to open the files <code>./foo.so</code>, <code>./foo.dll</code>,
-and <code>/usr/local/foo/init.so</code>, in that order.
-Once it finds a C&nbsp;library,
-this searcher first uses a dynamic link facility to link the
-application with the library.
-Then it tries to find a C&nbsp;function inside the library to
-be used as the loader.
-The name of this C&nbsp;function is the string "<code>luaopen_</code>"
-concatenated with a copy of the module name where each dot
-is replaced by an underscore.
-Moreover, if the module name has a hyphen,
-its prefix up to (and including) the first hyphen is removed.
-For instance, if the module name is <code>a.v1-b.c</code>,
-the function name will be <code>luaopen_b_c</code>.
-
-
-<p>
-The fourth searcher tries an <em>all-in-one loader</em>.
-It searches the C&nbsp;path for a library for
-the root name of the given module.
-For instance, when requiring <code>a.b.c</code>,
-it will search for a C&nbsp;library for <code>a</code>.
-If found, it looks into it for an open function for
-the submodule;
-in our example, that would be <code>luaopen_a_b_c</code>.
-With this facility, a package can pack several C&nbsp;submodules
-into one single library,
-with each submodule keeping its original open function.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3>
-
-
-<p>
-Dynamically links the host program with the C&nbsp;library <code>libname</code>.
-Inside this library, looks for a function <code>funcname</code>
-and returns this function as a C&nbsp;function.
-(So, <code>funcname</code> must follow the protocol (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>)).
-
-
-<p>
-This is a low-level function.
-It completely bypasses the package and module system.
-Unlike <a href="#pdf-require"><code>require</code></a>,
-it does not perform any path searching and
-does not automatically adds extensions.
-<code>libname</code> must be the complete file name of the C&nbsp;library,
-including if necessary a path and extension.
-<code>funcname</code> must be the exact name exported by the C&nbsp;library
-(which may depend on the C&nbsp;compiler and linker used).
-
-
-<p>
-This function is not supported by ANSI C.
-As such, it is only available on some platforms
-(Windows, Linux, Mac OS X, Solaris, BSD,
-plus other Unix systems that support the <code>dlfcn</code> standard).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.path"><code>package.path</code></a></h3>
-
-
-<p>
-The path used by <a href="#pdf-require"><code>require</code></a> to search for a Lua loader.
-
-
-<p>
-At start-up, Lua initializes this variable with
-the value of the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
-with a default path defined in <code>luaconf.h</code>,
-if the environment variable is not defined.
-Any "<code>;;</code>" in the value of the environment variable
-is replaced by the default path.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.preload"><code>package.preload</code></a></h3>
-
-
-<p>
-A table to store loaders for specific modules
-(see <a href="#pdf-require"><code>require</code></a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.seeall"><code>package.seeall (module)</code></a></h3>
-
-
-<p>
-Sets a metatable for <code>module</code> with
-its <code>__index</code> field referring to the global environment,
-so that this module inherits values
-from the global environment.
-To be used as an option to function <a href="#pdf-module"><code>module</code></a>.
-
-
-
-
-
-
-
-<h2>5.4 - <a name="5.4">String Manipulation</a></h2>
-
-<p>
-This library provides generic functions for string manipulation,
-such as finding and extracting substrings, and pattern matching.
-When indexing a string in Lua, the first character is at position&nbsp;1
-(not at&nbsp;0, as in C).
-Indices are allowed to be negative and are interpreted as indexing backwards,
-from the end of the string.
-Thus, the last character is at position -1, and so on.
-
-
-<p>
-The string library provides all its functions inside the table
-<a name="pdf-string"><code>string</code></a>.
-It also sets a metatable for strings
-where the <code>__index</code> field points to the <code>string</code> table.
-Therefore, you can use the string functions in object-oriented style.
-For instance, <code>string.byte(s, i)</code>
-can be written as <code>s:byte(i)</code>.
-
-
-<p>
-The string library assumes one-byte character encodings.
-
-
-<p>
-<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>
-Returns the internal numerical codes of the characters <code>s[i]</code>,
-<code>s[i+1]</code>, &middot;&middot;&middot;, <code>s[j]</code>.
-The default value for <code>i</code> is&nbsp;1;
-the default value for <code>j</code> is&nbsp;<code>i</code>.
-
-
-<p>
-Note that numerical codes are not necessarily portable across platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.char"><code>string.char (&middot;&middot;&middot;)</code></a></h3>
-Receives zero or more integers.
-Returns a string with length equal to the number of arguments,
-in which each character has the internal numerical code equal
-to its corresponding argument.
-
-
-<p>
-Note that numerical codes are not necessarily portable across platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.dump"><code>string.dump (function)</code></a></h3>
-
-
-<p>
-Returns a string containing a binary representation of the given function,
-so that a later <a href="#pdf-loadstring"><code>loadstring</code></a> on this string returns
-a copy of the function.
-<code>function</code> must be a Lua function without upvalues.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
-Looks for the first match of
-<code>pattern</code> in the string <code>s</code>.
-If it finds a match, then <code>find</code> returns the indices of&nbsp;<code>s</code>
-where this occurrence starts and ends;
-otherwise, it returns <b>nil</b>.
-A third, optional numerical argument <code>init</code> specifies
-where to start the search;
-its default value is&nbsp;1 and can be negative.
-A value of <b>true</b> as a fourth, optional argument <code>plain</code>
-turns off the pattern matching facilities,
-so the function does a plain "find substring" operation,
-with no characters in <code>pattern</code> being considered "magic".
-Note that if <code>plain</code> is given, then <code>init</code> must be given as well.
-
-
-<p>
-If the pattern has captures,
-then in a successful match
-the captured values are also returned,
-after the two indices.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.format"><code>string.format (formatstring, &middot;&middot;&middot;)</code></a></h3>
-Returns a formatted version of its variable number of arguments
-following the description given in its first argument (which must be a string).
-The format string follows the same rules as the <code>printf</code> family of
-standard C&nbsp;functions.
-The only differences are that the options/modifiers
-<code>*</code>, <code>l</code>, <code>L</code>, <code>n</code>, <code>p</code>,
-and <code>h</code> are not supported
-and that there is an extra option, <code>q</code>.
-The <code>q</code> option formats a string in a form suitable to be safely read
-back by the Lua interpreter:
-the string is written between double quotes,
-and all double quotes, newlines, embedded zeros,
-and backslashes in the string
-are correctly escaped when written.
-For instance, the call
-
-<pre>
-     string.format('%q', 'a string with "quotes" and \n new line')
-</pre><p>
-will produce the string:
-
-<pre>
-     "a string with \"quotes\" and \
-      new line"
-</pre>
-
-<p>
-The options <code>c</code>, <code>d</code>, <code>E</code>, <code>e</code>, <code>f</code>,
-<code>g</code>, <code>G</code>, <code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code> all
-expect a number as argument,
-whereas <code>q</code> and <code>s</code> expect a string.
-
-
-<p>
-This function does not accept string values
-containing embedded zeros,
-except as arguments to the <code>q</code> option.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>
-Returns an iterator function that,
-each time it is called,
-returns the next captures from <code>pattern</code> over string <code>s</code>.
-If <code>pattern</code> specifies no captures,
-then the whole match is produced in each call.
-
-
-<p>
-As an example, the following loop
-
-<pre>
-     s = "hello world from Lua"
-     for w in string.gmatch(s, "%a+") do
-       print(w)
-     end
-</pre><p>
-will iterate over all the words from string <code>s</code>,
-printing one per line.
-The next example collects all pairs <code>key=value</code> from the
-given string into a table:
-
-<pre>
-     t = {}
-     s = "from=world, to=Lua"
-     for k, v in string.gmatch(s, "(%w+)=(%w+)") do
-       t[k] = v
-     end
-</pre>
-
-<p>
-For this function, a '<code>^</code>' at the start of a pattern does not
-work as an anchor, as this would prevent the iteration.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>
-Returns a copy of <code>s</code>
-in which all (or the first <code>n</code>, if given)
-occurrences of the <code>pattern</code> have been
-replaced by a replacement string specified by <code>repl</code>,
-which can be a string, a table, or a function.
-<code>gsub</code> also returns, as its second value,
-the total number of matches that occurred.
-
-
-<p>
-If <code>repl</code> is a string, then its value is used for replacement.
-The character&nbsp;<code>%</code> works as an escape character:
-any sequence in <code>repl</code> of the form <code>%<em>n</em></code>,
-with <em>n</em> between 1 and 9,
-stands for the value of the <em>n</em>-th captured substring (see below).
-The sequence <code>%0</code> stands for the whole match.
-The sequence <code>%%</code> stands for a single&nbsp;<code>%</code>.
-
-
-<p>
-If <code>repl</code> is a table, then the table is queried for every match,
-using the first capture as the key;
-if the pattern specifies no captures,
-then the whole match is used as the key.
-
-
-<p>
-If <code>repl</code> is a function, then this function is called every time a
-match occurs, with all captured substrings passed as arguments,
-in order;
-if the pattern specifies no captures,
-then the whole match is passed as a sole argument.
-
-
-<p>
-If the value returned by the table query or by the function call
-is a string or a number,
-then it is used as the replacement string;
-otherwise, if it is <b>false</b> or <b>nil</b>,
-then there is no replacement
-(that is, the original match is kept in the string).
-
-
-<p>
-Here are some examples:
-
-<pre>
-     x = string.gsub("hello world", "(%w+)", "%1 %1")
-     --&gt; x="hello hello world world"
-
-     x = string.gsub("hello world", "%w+", "%0 %0", 1)
-     --&gt; x="hello hello world"
-
-     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
-     --&gt; x="world hello Lua from"
-
-     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
-     --&gt; x="home = /home/roberto, user = roberto"
-
-     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
-           return loadstring(s)()
-         end)
-     --&gt; x="4+5 = 9"
-
-     local t = {name="lua", version="5.1"}
-     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
-     --&gt; x="lua-5.1.tar.gz"
-</pre>
-
-
-
-<p>
-<hr><h3><a name="pdf-string.len"><code>string.len (s)</code></a></h3>
-Receives a string and returns its length.
-The empty string <code>""</code> has length 0.
-Embedded zeros are counted,
-so <code>"a\000bc\000"</code> has length 5.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.lower"><code>string.lower (s)</code></a></h3>
-Receives a string and returns a copy of this string with all
-uppercase letters changed to lowercase.
-All other characters are left unchanged.
-The definition of what an uppercase letter is depends on the current locale.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>
-Looks for the first <em>match</em> of
-<code>pattern</code> in the string <code>s</code>.
-If it finds one, then <code>match</code> returns
-the captures from the pattern;
-otherwise it returns <b>nil</b>.
-If <code>pattern</code> specifies no captures,
-then the whole match is returned.
-A third, optional numerical argument <code>init</code> specifies
-where to start the search;
-its default value is&nbsp;1 and can be negative.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n)</code></a></h3>
-Returns a string that is the concatenation of <code>n</code> copies of
-the string <code>s</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.reverse"><code>string.reverse (s)</code></a></h3>
-Returns a string that is the string <code>s</code> reversed.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.sub"><code>string.sub (s, i [, j])</code></a></h3>
-Returns the substring of <code>s</code> that
-starts at <code>i</code>  and continues until <code>j</code>;
-<code>i</code> and <code>j</code> can be negative.
-If <code>j</code> is absent, then it is assumed to be equal to -1
-(which is the same as the string length).
-In particular,
-the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code>
-with length <code>j</code>,
-and <code>string.sub(s, -i)</code> returns a suffix of <code>s</code>
-with length <code>i</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>
-Receives a string and returns a copy of this string with all
-lowercase letters changed to uppercase.
-All other characters are left unchanged.
-The definition of what a lowercase letter is depends on the current locale.
-
-
-
-<h3>5.4.1 - <a name="5.4.1">Patterns</a></h3>
-
-
-<h4>Character Class:</h4><p>
-A <em>character class</em> is used to represent a set of characters.
-The following combinations are allowed in describing a character class:
-
-<ul>
-
-<li><b><em>x</em>:</b>
-(where <em>x</em> is not one of the <em>magic characters</em>
-<code>^$()%.[]*+-?</code>)
-represents the character <em>x</em> itself.
-</li>
-
-<li><b><code>.</code>:</b> (a dot) represents all characters.</li>
-
-<li><b><code>%a</code>:</b> represents all letters.</li>
-
-<li><b><code>%c</code>:</b> represents all control characters.</li>
-
-<li><b><code>%d</code>:</b> represents all digits.</li>
-
-<li><b><code>%l</code>:</b> represents all lowercase letters.</li>
-
-<li><b><code>%p</code>:</b> represents all punctuation characters.</li>
-
-<li><b><code>%s</code>:</b> represents all space characters.</li>
-
-<li><b><code>%u</code>:</b> represents all uppercase letters.</li>
-
-<li><b><code>%w</code>:</b> represents all alphanumeric characters.</li>
-
-<li><b><code>%x</code>:</b> represents all hexadecimal digits.</li>
-
-<li><b><code>%z</code>:</b> represents the character with representation 0.</li>
-
-<li><b><code>%<em>x</em></code>:</b> (where <em>x</em> is any non-alphanumeric character)
-represents the character <em>x</em>.
-This is the standard way to escape the magic characters.
-Any punctuation character (even the non magic)
-can be preceded by a '<code>%</code>'
-when used to represent itself in a pattern.
-</li>
-
-<li><b><code>[<em>set</em>]</code>:</b>
-represents the class which is the union of all
-characters in <em>set</em>.
-A range of characters can be specified by
-separating the end characters of the range with a '<code>-</code>'.
-All classes <code>%</code><em>x</em> described above can also be used as
-components in <em>set</em>.
-All other characters in <em>set</em> represent themselves.
-For example, <code>[%w_]</code> (or <code>[_%w]</code>)
-represents all alphanumeric characters plus the underscore,
-<code>[0-7]</code> represents the octal digits,
-and <code>[0-7%l%-]</code> represents the octal digits plus
-the lowercase letters plus the '<code>-</code>' character.
-
-
-<p>
-The interaction between ranges and classes is not defined.
-Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code>
-have no meaning.
-</li>
-
-<li><b><code>[^<em>set</em>]</code>:</b>
-represents the complement of <em>set</em>,
-where <em>set</em> is interpreted as above.
-</li>
-
-</ul><p>
-For all classes represented by single letters (<code>%a</code>, <code>%c</code>, etc.),
-the corresponding uppercase letter represents the complement of the class.
-For instance, <code>%S</code> represents all non-space characters.
-
-
-<p>
-The definitions of letter, space, and other character groups
-depend on the current locale.
-In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>.
-
-
-
-
-
-<h4>Pattern Item:</h4><p>
-A <em>pattern item</em> can be
-
-<ul>
-
-<li>
-a single character class,
-which matches any single character in the class;
-</li>
-
-<li>
-a single character class followed by '<code>*</code>',
-which matches 0 or more repetitions of characters in the class.
-These repetition items will always match the longest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>+</code>',
-which matches 1 or more repetitions of characters in the class.
-These repetition items will always match the longest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>-</code>',
-which also matches 0 or more repetitions of characters in the class.
-Unlike '<code>*</code>',
-these repetition items will always match the <em>shortest</em> possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>?</code>',
-which matches 0 or 1 occurrence of a character in the class;
-</li>
-
-<li>
-<code>%<em>n</em></code>, for <em>n</em> between 1 and 9;
-such item matches a substring equal to the <em>n</em>-th captured string
-(see below);
-</li>
-
-<li>
-<code>%b<em>xy</em></code>, where <em>x</em> and <em>y</em> are two distinct characters;
-such item matches strings that start with&nbsp;<em>x</em>, end with&nbsp;<em>y</em>,
-and where the <em>x</em> and <em>y</em> are <em>balanced</em>.
-This means that, if one reads the string from left to right,
-counting <em>+1</em> for an <em>x</em> and <em>-1</em> for a <em>y</em>,
-the ending <em>y</em> is the first <em>y</em> where the count reaches 0.
-For instance, the item <code>%b()</code> matches expressions with
-balanced parentheses.
-</li>
-
-</ul>
-
-
-
-
-<h4>Pattern:</h4><p>
-A <em>pattern</em> is a sequence of pattern items.
-A '<code>^</code>' at the beginning of a pattern anchors the match at the
-beginning of the subject string.
-A '<code>$</code>' at the end of a pattern anchors the match at the
-end of the subject string.
-At other positions,
-'<code>^</code>' and '<code>$</code>' have no special meaning and represent themselves.
-
-
-
-
-
-<h4>Captures:</h4><p>
-A pattern can contain sub-patterns enclosed in parentheses;
-they describe <em>captures</em>.
-When a match succeeds, the substrings of the subject string
-that match captures are stored (<em>captured</em>) for future use.
-Captures are numbered according to their left parentheses.
-For instance, in the pattern <code>"(a*(.)%w(%s*))"</code>,
-the part of the string matching <code>"a*(.)%w(%s*)"</code> is
-stored as the first capture (and therefore has number&nbsp;1);
-the character matching "<code>.</code>" is captured with number&nbsp;2,
-and the part matching "<code>%s*</code>" has number&nbsp;3.
-
-
-<p>
-As a special case, the empty capture <code>()</code> captures
-the current string position (a number).
-For instance, if we apply the pattern <code>"()aa()"</code> on the
-string <code>"flaaap"</code>, there will be two captures: 3&nbsp;and&nbsp;5.
-
-
-<p>
-A pattern cannot contain embedded zeros.  Use <code>%z</code> instead.
-
-
-
-
-
-
-
-
-
-
-
-<h2>5.5 - <a name="5.5">Table Manipulation</a></h2><p>
-This library provides generic functions for table manipulation.
-It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
-
-
-<p>
-Most functions in the table library assume that the table
-represents an array or a list.
-For these functions, when we talk about the "length" of a table
-we mean the result of the length operator.
-
-
-<p>
-<hr><h3><a name="pdf-table.concat"><code>table.concat (table [, sep [, i [, j]]])</code></a></h3>
-Given an array where all elements are strings or numbers,
-returns <code>table[i]..sep..table[i+1] &middot;&middot;&middot; sep..table[j]</code>.
-The default value for <code>sep</code> is the empty string,
-the default for <code>i</code> is 1,
-and the default for <code>j</code> is the length of the table.
-If <code>i</code> is greater than <code>j</code>, returns the empty string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.insert"><code>table.insert (table, [pos,] value)</code></a></h3>
-
-
-<p>
-Inserts element <code>value</code> at position <code>pos</code> in <code>table</code>,
-shifting up other elements to open space, if necessary.
-The default value for <code>pos</code> is <code>n+1</code>,
-where <code>n</code> is the length of the table (see <a href="#2.5.5">&sect;2.5.5</a>),
-so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
-of table <code>t</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.maxn"><code>table.maxn (table)</code></a></h3>
-
-
-<p>
-Returns the largest positive numerical index of the given table,
-or zero if the table has no positive numerical indices.
-(To do its job this function does a linear traversal of
-the whole table.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.remove"><code>table.remove (table [, pos])</code></a></h3>
-
-
-<p>
-Removes from <code>table</code> the element at position <code>pos</code>,
-shifting down other elements to close the space, if necessary.
-Returns the value of the removed element.
-The default value for <code>pos</code> is <code>n</code>,
-where <code>n</code> is the length of the table,
-so that a call <code>table.remove(t)</code> removes the last element
-of table <code>t</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.sort"><code>table.sort (table [, comp])</code></a></h3>
-Sorts table elements in a given order, <em>in-place</em>,
-from <code>table[1]</code> to <code>table[n]</code>,
-where <code>n</code> is the length of the table.
-If <code>comp</code> is given,
-then it must be a function that receives two table elements,
-and returns true
-when the first is less than the second
-(so that <code>not comp(a[i+1],a[i])</code> will be true after the sort).
-If <code>comp</code> is not given,
-then the standard Lua operator <code>&lt;</code> is used instead.
-
-
-<p>
-The sort algorithm is not stable;
-that is, elements considered equal by the given order
-may have their relative positions changed by the sort.
-
-
-
-
-
-
-
-<h2>5.6 - <a name="5.6">Mathematical Functions</a></h2>
-
-<p>
-This library is an interface to the standard C&nbsp;math library.
-It provides all its functions inside the table <a name="pdf-math"><code>math</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-math.abs"><code>math.abs (x)</code></a></h3>
-
-
-<p>
-Returns the absolute value of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.acos"><code>math.acos (x)</code></a></h3>
-
-
-<p>
-Returns the arc cosine of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.asin"><code>math.asin (x)</code></a></h3>
-
-
-<p>
-Returns the arc sine of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.atan"><code>math.atan (x)</code></a></h3>
-
-
-<p>
-Returns the arc tangent of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.atan2"><code>math.atan2 (y, x)</code></a></h3>
-
-
-<p>
-Returns the arc tangent of <code>y/x</code> (in radians),
-but uses the signs of both parameters to find the
-quadrant of the result.
-(It also handles correctly the case of <code>x</code> being zero.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
-
-
-<p>
-Returns the smallest integer larger than or equal to <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>
-
-
-<p>
-Returns the cosine of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.cosh"><code>math.cosh (x)</code></a></h3>
-
-
-<p>
-Returns the hyperbolic cosine of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.deg"><code>math.deg (x)</code></a></h3>
-
-
-<p>
-Returns the angle <code>x</code> (given in radians) in degrees.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3>
-
-
-<p>
-Returns the value <em>e<sup>x</sup></em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.floor"><code>math.floor (x)</code></a></h3>
-
-
-<p>
-Returns the largest integer smaller than or equal to <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.fmod"><code>math.fmod (x, y)</code></a></h3>
-
-
-<p>
-Returns the remainder of the division of <code>x</code> by <code>y</code>
-that rounds the quotient towards zero.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.frexp"><code>math.frexp (x)</code></a></h3>
-
-
-<p>
-Returns <code>m</code> and <code>e</code> such that <em>x = m2<sup>e</sup></em>,
-<code>e</code> is an integer and the absolute value of <code>m</code> is
-in the range <em>[0.5, 1)</em>
-(or zero when <code>x</code> is zero).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.huge"><code>math.huge</code></a></h3>
-
-
-<p>
-The value <code>HUGE_VAL</code>,
-a value larger than or equal to any other numerical value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.ldexp"><code>math.ldexp (m, e)</code></a></h3>
-
-
-<p>
-Returns <em>m2<sup>e</sup></em> (<code>e</code> should be an integer).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.log"><code>math.log (x)</code></a></h3>
-
-
-<p>
-Returns the natural logarithm of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.log10"><code>math.log10 (x)</code></a></h3>
-
-
-<p>
-Returns the base-10 logarithm of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.max"><code>math.max (x, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns the maximum value among its arguments.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.min"><code>math.min (x, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns the minimum value among its arguments.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>
-
-
-<p>
-Returns two numbers,
-the integral part of <code>x</code> and the fractional part of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>
-
-
-<p>
-The value of <em>pi</em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.pow"><code>math.pow (x, y)</code></a></h3>
-
-
-<p>
-Returns <em>x<sup>y</sup></em>.
-(You can also use the expression <code>x^y</code> to compute this value.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.rad"><code>math.rad (x)</code></a></h3>
-
-
-<p>
-Returns the angle <code>x</code> (given in degrees) in radians.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>
-
-
-<p>
-This function is an interface to the simple
-pseudo-random generator function <code>rand</code> provided by ANSI&nbsp;C.
-(No guarantees can be given for its statistical properties.)
-
-
-<p>
-When called without arguments,
-returns a uniform pseudo-random real number
-in the range <em>[0,1)</em>.
-When called with an integer number <code>m</code>,
-<code>math.random</code> returns
-a uniform pseudo-random integer in the range <em>[1, m]</em>.
-When called with two integer numbers <code>m</code> and <code>n</code>,
-<code>math.random</code> returns a uniform pseudo-random
-integer in the range <em>[m, n]</em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.randomseed"><code>math.randomseed (x)</code></a></h3>
-
-
-<p>
-Sets <code>x</code> as the "seed"
-for the pseudo-random generator:
-equal seeds produce equal sequences of numbers.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sin"><code>math.sin (x)</code></a></h3>
-
-
-<p>
-Returns the sine of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sinh"><code>math.sinh (x)</code></a></h3>
-
-
-<p>
-Returns the hyperbolic sine of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>
-
-
-<p>
-Returns the square root of <code>x</code>.
-(You can also use the expression <code>x^0.5</code> to compute this value.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.tan"><code>math.tan (x)</code></a></h3>
-
-
-<p>
-Returns the tangent of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.tanh"><code>math.tanh (x)</code></a></h3>
-
-
-<p>
-Returns the hyperbolic tangent of <code>x</code>.
-
-
-
-
-
-
-
-<h2>5.7 - <a name="5.7">Input and Output Facilities</a></h2>
-
-<p>
-The I/O library provides two different styles for file manipulation.
-The first one uses implicit file descriptors;
-that is, there are operations to set a default input file and a
-default output file,
-and all input/output operations are over these default files.
-The second style uses explicit file descriptors.
-
-
-<p>
-When using implicit file descriptors,
-all operations are supplied by table <a name="pdf-io"><code>io</code></a>.
-When using explicit file descriptors,
-the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file descriptor
-and then all operations are supplied as methods of the file descriptor.
-
-
-<p>
-The table <code>io</code> also provides
-three predefined file descriptors with their usual meanings from C:
-<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.
-The I/O library never closes these files.
-
-
-<p>
-Unless otherwise stated,
-all I/O functions return <b>nil</b> on failure
-(plus an error message as a second result and
-a system-dependent error code as a third result)
-and some value different from <b>nil</b> on success.
-
-
-<p>
-<hr><h3><a name="pdf-io.close"><code>io.close ([file])</code></a></h3>
-
-
-<p>
-Equivalent to <code>file:close()</code>.
-Without a <code>file</code>, closes the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.flush"><code>io.flush ()</code></a></h3>
-
-
-<p>
-Equivalent to <code>file:flush</code> over the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.input"><code>io.input ([file])</code></a></h3>
-
-
-<p>
-When called with a file name, it opens the named file (in text mode),
-and sets its handle as the default input file.
-When called with a file handle,
-it simply sets this file handle as the default input file.
-When called without parameters,
-it returns the current default input file.
-
-
-<p>
-In case of errors this function raises the error,
-instead of returning an error code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename])</code></a></h3>
-
-
-<p>
-Opens the given file name in read mode
-and returns an iterator function that,
-each time it is called,
-returns a new line from the file.
-Therefore, the construction
-
-<pre>
-     for line in io.lines(filename) do <em>body</em> end
-</pre><p>
-will iterate over all lines of the file.
-When the iterator function detects the end of file,
-it returns <b>nil</b> (to finish the loop) and automatically closes the file.
-
-
-<p>
-The call <code>io.lines()</code> (with no file name) is equivalent
-to <code>io.input():lines()</code>;
-that is, it iterates over the lines of the default input file.
-In this case it does not close the file when the loop ends.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.open"><code>io.open (filename [, mode])</code></a></h3>
-
-
-<p>
-This function opens a file,
-in the mode specified in the string <code>mode</code>.
-It returns a new file handle,
-or, in case of errors, <b>nil</b> plus an error message.
-
-
-<p>
-The <code>mode</code> string can be any of the following:
-
-<ul>
-<li><b>"r":</b> read mode (the default);</li>
-<li><b>"w":</b> write mode;</li>
-<li><b>"a":</b> append mode;</li>
-<li><b>"r+":</b> update mode, all previous data is preserved;</li>
-<li><b>"w+":</b> update mode, all previous data is erased;</li>
-<li><b>"a+":</b> append update mode, previous data is preserved,
-  writing is only allowed at the end of file.</li>
-</ul><p>
-The <code>mode</code> string can also have a '<code>b</code>' at the end,
-which is needed in some systems to open the file in binary mode.
-This string is exactly what is used in the
-standard&nbsp;C function <code>fopen</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.output"><code>io.output ([file])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>
-
-
-<p>
-Starts program <code>prog</code> in a separated process and returns
-a file handle that you can use to read data from this program
-(if <code>mode</code> is <code>"r"</code>, the default)
-or to write data to this program
-(if <code>mode</code> is <code>"w"</code>).
-
-
-<p>
-This function is system dependent and is not available
-on all platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.read"><code>io.read (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.input():read</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.tmpfile"><code>io.tmpfile ()</code></a></h3>
-
-
-<p>
-Returns a handle for a temporary file.
-This file is opened in update mode
-and it is automatically removed when the program ends.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.type"><code>io.type (obj)</code></a></h3>
-
-
-<p>
-Checks whether <code>obj</code> is a valid file handle.
-Returns the string <code>"file"</code> if <code>obj</code> is an open file handle,
-<code>"closed file"</code> if <code>obj</code> is a closed file handle,
-or <b>nil</b> if <code>obj</code> is not a file handle.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.write"><code>io.write (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.output():write</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:close"><code>file:close ()</code></a></h3>
-
-
-<p>
-Closes <code>file</code>.
-Note that files are automatically closed when
-their handles are garbage collected,
-but that takes an unpredictable amount of time to happen.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:flush"><code>file:flush ()</code></a></h3>
-
-
-<p>
-Saves any written data to <code>file</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:lines"><code>file:lines ()</code></a></h3>
-
-
-<p>
-Returns an iterator function that,
-each time it is called,
-returns a new line from the file.
-Therefore, the construction
-
-<pre>
-     for line in file:lines() do <em>body</em> end
-</pre><p>
-will iterate over all lines of the file.
-(Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
-when the loop ends.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:read"><code>file:read (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Reads the file <code>file</code>,
-according to the given formats, which specify what to read.
-For each format,
-the function returns a string (or a number) with the characters read,
-or <b>nil</b> if it cannot read data with the specified format.
-When called without formats,
-it uses a default format that reads the entire next line
-(see below).
-
-
-<p>
-The available formats are
-
-<ul>
-
-<li><b>"*n":</b>
-reads a number;
-this is the only format that returns a number instead of a string.
-</li>
-
-<li><b>"*a":</b>
-reads the whole file, starting at the current position.
-On end of file, it returns the empty string.
-</li>
-
-<li><b>"*l":</b>
-reads the next line (skipping the end of line),
-returning <b>nil</b> on end of file.
-This is the default format.
-</li>
-
-<li><b><em>number</em>:</b>
-reads a string with up to this number of characters,
-returning <b>nil</b> on end of file.
-If number is zero,
-it reads nothing and returns an empty string,
-or <b>nil</b> on end of file.
-</li>
-
-</ul>
-
-
-
-<p>
-<hr><h3><a name="pdf-file:seek"><code>file:seek ([whence] [, offset])</code></a></h3>
-
-
-<p>
-Sets and gets the file position,
-measured from the beginning of the file,
-to the position given by <code>offset</code> plus a base
-specified by the string <code>whence</code>, as follows:
-
-<ul>
-<li><b>"set":</b> base is position 0 (beginning of the file);</li>
-<li><b>"cur":</b> base is current position;</li>
-<li><b>"end":</b> base is end of file;</li>
-</ul><p>
-In case of success, function <code>seek</code> returns the final file position,
-measured in bytes from the beginning of the file.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-<p>
-The default value for <code>whence</code> is <code>"cur"</code>,
-and for <code>offset</code> is 0.
-Therefore, the call <code>file:seek()</code> returns the current
-file position, without changing it;
-the call <code>file:seek("set")</code> sets the position to the
-beginning of the file (and returns 0);
-and the call <code>file:seek("end")</code> sets the position to the
-end of the file, and returns its size.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:setvbuf"><code>file:setvbuf (mode [, size])</code></a></h3>
-
-
-<p>
-Sets the buffering mode for an output file.
-There are three available modes:
-
-<ul>
-
-<li><b>"no":</b>
-no buffering; the result of any output operation appears immediately.
-</li>
-
-<li><b>"full":</b>
-full buffering; output operation is performed only
-when the buffer is full (or when you explicitly <code>flush</code> the file
-(see <a href="#pdf-io.flush"><code>io.flush</code></a>)).
-</li>
-
-<li><b>"line":</b>
-line buffering; output is buffered until a newline is output
-or there is any input from some special files
-(such as a terminal device).
-</li>
-
-</ul><p>
-For the last two cases, <code>size</code>
-specifies the size of the buffer, in bytes.
-The default is an appropriate size.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:write"><code>file:write (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Writes the value of each of its arguments to
-the <code>file</code>.
-The arguments must be strings or numbers.
-To write other values,
-use <a href="#pdf-tostring"><code>tostring</code></a> or <a href="#pdf-string.format"><code>string.format</code></a> before <code>write</code>.
-
-
-
-
-
-
-
-<h2>5.8 - <a name="5.8">Operating System Facilities</a></h2>
-
-<p>
-This library is implemented through table <a name="pdf-os"><code>os</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-os.clock"><code>os.clock ()</code></a></h3>
-
-
-<p>
-Returns an approximation of the amount in seconds of CPU time
-used by the program.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.date"><code>os.date ([format [, time]])</code></a></h3>
-
-
-<p>
-Returns a string or a table containing date and time,
-formatted according to the given string <code>format</code>.
-
-
-<p>
-If the <code>time</code> argument is present,
-this is the time to be formatted
-(see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value).
-Otherwise, <code>date</code> formats the current time.
-
-
-<p>
-If <code>format</code> starts with '<code>!</code>',
-then the date is formatted in Coordinated Universal Time.
-After this optional character,
-if <code>format</code> is the string "<code>*t</code>",
-then <code>date</code> returns a table with the following fields:
-<code>year</code> (four digits), <code>month</code> (1--12), <code>day</code> (1--31),
-<code>hour</code> (0--23), <code>min</code> (0--59), <code>sec</code> (0--61),
-<code>wday</code> (weekday, Sunday is&nbsp;1),
-<code>yday</code> (day of the year),
-and <code>isdst</code> (daylight saving flag, a boolean).
-
-
-<p>
-If <code>format</code> is not "<code>*t</code>",
-then <code>date</code> returns the date as a string,
-formatted according to the same rules as the C&nbsp;function <code>strftime</code>.
-
-
-<p>
-When called without arguments,
-<code>date</code> returns a reasonable date and time representation that depends on
-the host system and on the current locale
-(that is, <code>os.date()</code> is equivalent to <code>os.date("%c")</code>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.difftime"><code>os.difftime (t2, t1)</code></a></h3>
-
-
-<p>
-Returns the number of seconds from time <code>t1</code> to time <code>t2</code>.
-In POSIX, Windows, and some other systems,
-this value is exactly <code>t2</code><em>-</em><code>t1</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.execute"><code>os.execute ([command])</code></a></h3>
-
-
-<p>
-This function is equivalent to the C&nbsp;function <code>system</code>.
-It passes <code>command</code> to be executed by an operating system shell.
-It returns a status code, which is system-dependent.
-If <code>command</code> is absent, then it returns nonzero if a shell is available
-and zero otherwise.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.exit"><code>os.exit ([code])</code></a></h3>
-
-
-<p>
-Calls the C&nbsp;function <code>exit</code>,
-with an optional <code>code</code>,
-to terminate the host program.
-The default value for <code>code</code> is the success code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.getenv"><code>os.getenv (varname)</code></a></h3>
-
-
-<p>
-Returns the value of the process environment variable <code>varname</code>,
-or <b>nil</b> if the variable is not defined.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.remove"><code>os.remove (filename)</code></a></h3>
-
-
-<p>
-Deletes the file or directory with the given name.
-Directories must be empty to be removed.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.rename"><code>os.rename (oldname, newname)</code></a></h3>
-
-
-<p>
-Renames file or directory named <code>oldname</code> to <code>newname</code>.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.setlocale"><code>os.setlocale (locale [, category])</code></a></h3>
-
-
-<p>
-Sets the current locale of the program.
-<code>locale</code> is a string specifying a locale;
-<code>category</code> is an optional string describing which category to change:
-<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,
-<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;
-the default category is <code>"all"</code>.
-The function returns the name of the new locale,
-or <b>nil</b> if the request cannot be honored.
-
-
-<p>
-If <code>locale</code> is the empty string,
-the current locale is set to an implementation-defined native locale.
-If <code>locale</code> is the string "<code>C</code>",
-the current locale is set to the standard C locale.
-
-
-<p>
-When called with <b>nil</b> as the first argument,
-this function only returns the name of the current locale
-for the given category.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.time"><code>os.time ([table])</code></a></h3>
-
-
-<p>
-Returns the current time when called without arguments,
-or a time representing the date and time specified by the given table.
-This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,
-and may have fields <code>hour</code>, <code>min</code>, <code>sec</code>, and <code>isdst</code>
-(for a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function).
-
-
-<p>
-The returned value is a number, whose meaning depends on your system.
-In POSIX, Windows, and some other systems, this number counts the number
-of seconds since some given start time (the "epoch").
-In other systems, the meaning is not specified,
-and the number returned by <code>time</code> can be used only as an argument to
-<code>date</code> and <code>difftime</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.tmpname"><code>os.tmpname ()</code></a></h3>
-
-
-<p>
-Returns a string with a file name that can
-be used for a temporary file.
-The file must be explicitly opened before its use
-and explicitly removed when no longer needed.
-
-
-<p>
-On some systems (POSIX),
-this function also creates a file with that name,
-to avoid security risks.
-(Someone else might create the file with wrong permissions
-in the time between getting the name and creating the file.)
-You still have to open the file to use it
-and to remove it (even if you do not use it).
-
-
-<p>
-When possible,
-you may prefer to use <a href="#pdf-io.tmpfile"><code>io.tmpfile</code></a>,
-which automatically removes the file when the program ends.
-
-
-
-
-
-
-
-<h2>5.9 - <a name="5.9">The Debug Library</a></h2>
-
-<p>
-This library provides
-the functionality of the debug interface to Lua programs.
-You should exert care when using this library.
-The functions provided here should be used exclusively for debugging
-and similar tasks, such as profiling.
-Please resist the temptation to use them as a
-usual programming tool:
-they can be very slow.
-Moreover, several of these functions
-violate some assumptions about Lua code
-(e.g., that variables local to a function
-cannot be accessed from outside or
-that userdata metatables cannot be changed by Lua code)
-and therefore can compromise otherwise secure code.
-
-
-<p>
-All functions in this library are provided
-inside the <a name="pdf-debug"><code>debug</code></a> table.
-All functions that operate over a thread
-have an optional first argument which is the
-thread to operate over.
-The default is always the current thread.
-
-
-<p>
-<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>
-
-
-<p>
-Enters an interactive mode with the user,
-running each string that the user enters.
-Using simple commands and other debug facilities,
-the user can inspect global and local variables,
-change their values, evaluate expressions, and so on.
-A line containing only the word <code>cont</code> finishes this function,
-so that the caller continues its execution.
-
-
-<p>
-Note that commands for <code>debug.debug</code> are not lexically nested
-within any function, and so have no direct access to local variables.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getfenv"><code>debug.getfenv (o)</code></a></h3>
-Returns the environment of object <code>o</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.gethook"><code>debug.gethook ([thread])</code></a></h3>
-
-
-<p>
-Returns the current hook settings of the thread, as three values:
-the current hook function, the current hook mask,
-and the current hook count
-(as set by the <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> function).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] function [, what])</code></a></h3>
-
-
-<p>
-Returns a table with information about a function.
-You can give the function directly,
-or you can give a number as the value of <code>function</code>,
-which means the function running at level <code>function</code> of the call stack
-of the given thread:
-level&nbsp;0 is the current function (<code>getinfo</code> itself);
-level&nbsp;1 is the function that called <code>getinfo</code>;
-and so on.
-If <code>function</code> is a number larger than the number of active functions,
-then <code>getinfo</code> returns <b>nil</b>.
-
-
-<p>
-The returned table can contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>,
-with the string <code>what</code> describing which fields to fill in.
-The default for <code>what</code> is to get all information available,
-except the table of valid lines.
-If present,
-the option '<code>f</code>'
-adds a field named <code>func</code> with the function itself.
-If present,
-the option '<code>L</code>'
-adds a field named <code>activelines</code> with the table of
-valid lines.
-
-
-<p>
-For instance, the expression <code>debug.getinfo(1,"n").name</code> returns
-a table with a name for the current function,
-if a reasonable name can be found,
-and the expression <code>debug.getinfo(print)</code>
-returns a table with all available information
-about the <a href="#pdf-print"><code>print</code></a> function.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] level, local)</code></a></h3>
-
-
-<p>
-This function returns the name and the value of the local variable
-with index <code>local</code> of the function at level <code>level</code> of the stack.
-(The first parameter or local variable has index&nbsp;1, and so on,
-until the last active local variable.)
-The function returns <b>nil</b> if there is no local
-variable with the given index,
-and raises an error when called with a <code>level</code> out of range.
-(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
-
-
-<p>
-Variable names starting with '<code>(</code>' (open parentheses)
-represent internal variables
-(loop control variables, temporaries, and C&nbsp;function locals).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (object)</code></a></h3>
-
-
-<p>
-Returns the metatable of the given <code>object</code>
-or <b>nil</b> if it does not have a metatable.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getregistry"><code>debug.getregistry ()</code></a></h3>
-
-
-<p>
-Returns the registry table (see <a href="#3.5">&sect;3.5</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (func, up)</code></a></h3>
-
-
-<p>
-This function returns the name and the value of the upvalue
-with index <code>up</code> of the function <code>func</code>.
-The function returns <b>nil</b> if there is no upvalue with the given index.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setfenv"><code>debug.setfenv (object, table)</code></a></h3>
-
-
-<p>
-Sets the environment of the given <code>object</code> to the given <code>table</code>.
-Returns <code>object</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
-
-
-<p>
-Sets the given function as a hook.
-The string <code>mask</code> and the number <code>count</code> describe
-when the hook will be called.
-The string mask may have the following characters,
-with the given meaning:
-
-<ul>
-<li><b><code>"c"</code>:</b> the hook is called every time Lua calls a function;</li>
-<li><b><code>"r"</code>:</b> the hook is called every time Lua returns from a function;</li>
-<li><b><code>"l"</code>:</b> the hook is called every time Lua enters a new line of code.</li>
-</ul><p>
-With a <code>count</code> different from zero,
-the hook is called after every <code>count</code> instructions.
-
-
-<p>
-When called without arguments,
-<a href="#pdf-debug.sethook"><code>debug.sethook</code></a> turns off the hook.
-
-
-<p>
-When the hook is called, its first parameter is a string
-describing the event that has triggered its call:
-<code>"call"</code>, <code>"return"</code> (or <code>"tail return"</code>,
-when simulating a return from a tail call),
-<code>"line"</code>, and <code>"count"</code>.
-For line events,
-the hook also gets the new line number as its second parameter.
-Inside a hook,
-you can call <code>getinfo</code> with level&nbsp;2 to get more information about
-the running function
-(level&nbsp;0 is the <code>getinfo</code> function,
-and level&nbsp;1 is the hook function),
-unless the event is <code>"tail return"</code>.
-In this case, Lua is only simulating the return,
-and a call to <code>getinfo</code> will return invalid data.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3>
-
-
-<p>
-This function assigns the value <code>value</code> to the local variable
-with index <code>local</code> of the function at level <code>level</code> of the stack.
-The function returns <b>nil</b> if there is no local
-variable with the given index,
-and raises an error when called with a <code>level</code> out of range.
-(You can call <code>getinfo</code> to check whether the level is valid.)
-Otherwise, it returns the name of the local variable.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (object, table)</code></a></h3>
-
-
-<p>
-Sets the metatable for the given <code>object</code> to the given <code>table</code>
-(which can be <b>nil</b>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (func, up, value)</code></a></h3>
-
-
-<p>
-This function assigns the value <code>value</code> to the upvalue
-with index <code>up</code> of the function <code>func</code>.
-The function returns <b>nil</b> if there is no upvalue
-with the given index.
-Otherwise, it returns the name of the upvalue.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message] [, level])</code></a></h3>
-
-
-<p>
-Returns a string with a traceback of the call stack.
-An optional <code>message</code> string is appended
-at the beginning of the traceback.
-An optional <code>level</code> number tells at which level
-to start the traceback
-(default is 1, the function calling <code>traceback</code>).
-
-
-
-
-
-
-
-<h1>6 - <a name="6">Lua Stand-alone</a></h1>
-
-<p>
-Although Lua has been designed as an extension language,
-to be embedded in a host C&nbsp;program,
-it is also frequently used as a stand-alone language.
-An interpreter for Lua as a stand-alone language,
-called simply <code>lua</code>,
-is provided with the standard distribution.
-The stand-alone interpreter includes
-all standard libraries, including the debug library.
-Its usage is:
-
-<pre>
-     lua [options] [script [args]]
-</pre><p>
-The options are:
-
-<ul>
-<li><b><code>-e <em>stat</em></code>:</b> executes string <em>stat</em>;</li>
-<li><b><code>-l <em>mod</em></code>:</b> "requires" <em>mod</em>;</li>
-<li><b><code>-i</code>:</b> enters interactive mode after running <em>script</em>;</li>
-<li><b><code>-v</code>:</b> prints version information;</li>
-<li><b><code>--</code>:</b> stops handling options;</li>
-<li><b><code>-</code>:</b> executes <code>stdin</code> as a file and stops handling options.</li>
-</ul><p>
-After handling its options, <code>lua</code> runs the given <em>script</em>,
-passing to it the given <em>args</em> as string arguments.
-When called without arguments,
-<code>lua</code> behaves as <code>lua -v -i</code>
-when the standard input (<code>stdin</code>) is a terminal,
-and as <code>lua -</code> otherwise.
-
-
-<p>
-Before running any argument,
-the interpreter checks for an environment variable <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a>.
-If its format is <code>@<em>filename</em></code>,
-then <code>lua</code> executes the file.
-Otherwise, <code>lua</code> executes the string itself.
-
-
-<p>
-All options are handled in order, except <code>-i</code>.
-For instance, an invocation like
-
-<pre>
-     $ lua -e'a=1' -e 'print(a)' script.lua
-</pre><p>
-will first set <code>a</code> to 1, then print the value of <code>a</code> (which is '<code>1</code>'),
-and finally run the file <code>script.lua</code> with no arguments.
-(Here <code>$</code> is the shell prompt. Your prompt may be different.)
-
-
-<p>
-Before starting to run the script,
-<code>lua</code> collects all arguments in the command line
-in a global table called <code>arg</code>.
-The script name is stored at index 0,
-the first argument after the script name goes to index 1,
-and so on.
-Any arguments before the script name
-(that is, the interpreter name plus the options)
-go to negative indices.
-For instance, in the call
-
-<pre>
-     $ lua -la b.lua t1 t2
-</pre><p>
-the interpreter first runs the file <code>a.lua</code>,
-then creates a table
-
-<pre>
-     arg = { [-2] = "lua", [-1] = "-la",
-             [0] = "b.lua",
-             [1] = "t1", [2] = "t2" }
-</pre><p>
-and finally runs the file <code>b.lua</code>.
-The script is called with <code>arg[1]</code>, <code>arg[2]</code>, &middot;&middot;&middot;
-as arguments;
-it can also access these arguments with the vararg expression '<code>...</code>'.
-
-
-<p>
-In interactive mode,
-if you write an incomplete statement,
-the interpreter waits for its completion
-by issuing a different prompt.
-
-
-<p>
-If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,
-then its value is used as the prompt.
-Similarly, if the global variable <a name="pdf-_PROMPT2"><code>_PROMPT2</code></a> contains a string,
-its value is used as the secondary prompt
-(issued during incomplete statements).
-Therefore, both prompts can be changed directly on the command line
-or in any Lua programs by assigning to <code>_PROMPT</code>.
-See the next example:
-
-<pre>
-     $ lua -e"_PROMPT='myprompt&gt; '" -i
-</pre><p>
-(The outer pair of quotes is for the shell,
-the inner pair is for Lua.)
-Note the use of <code>-i</code> to enter interactive mode;
-otherwise,
-the program would just end silently
-right after the assignment to <code>_PROMPT</code>.
-
-
-<p>
-To allow the use of Lua as a
-script interpreter in Unix systems,
-the stand-alone interpreter skips
-the first line of a chunk if it starts with <code>#</code>.
-Therefore, Lua scripts can be made into executable programs
-by using <code>chmod +x</code> and the&nbsp;<code>#!</code> form,
-as in
-
-<pre>
-     #!/usr/local/bin/lua
-</pre><p>
-(Of course,
-the location of the Lua interpreter may be different in your machine.
-If <code>lua</code> is in your <code>PATH</code>,
-then
-
-<pre>
-     #!/usr/bin/env lua
-</pre><p>
-is a more portable solution.)
-
-
-
-<h1>7 - <a name="7">Incompatibilities with the Previous Version</a></h1>
-
-<p>
-Here we list the incompatibilities that you may find when moving a program
-from Lua&nbsp;5.0 to Lua&nbsp;5.1.
-You can avoid most of the incompatibilities compiling Lua with
-appropriate options (see file <code>luaconf.h</code>).
-However,
-all these compatibility options will be removed in the next version of Lua.
-
-
-
-<h2>7.1 - <a name="7.1">Changes in the Language</a></h2>
-<ul>
-
-<li>
-The vararg system changed from the pseudo-argument <code>arg</code> with a
-table with the extra arguments to the vararg expression.
-(See compile-time option <code>LUA_COMPAT_VARARG</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-There was a subtle change in the scope of the implicit
-variables of the <b>for</b> statement and for the <b>repeat</b> statement.
-</li>
-
-<li>
-The long string/long comment syntax (<code>[[<em>string</em>]]</code>)
-does not allow nesting.
-You can use the new syntax (<code>[=[<em>string</em>]=]</code>) in these cases.
-(See compile-time option <code>LUA_COMPAT_LSTR</code> in <code>luaconf.h</code>.)
-</li>
-
-</ul>
-
-
-
-
-<h2>7.2 - <a name="7.2">Changes in the Libraries</a></h2>
-<ul>
-
-<li>
-Function <code>string.gfind</code> was renamed <a href="#pdf-string.gmatch"><code>string.gmatch</code></a>.
-(See compile-time option <code>LUA_COMPAT_GFIND</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-When <a href="#pdf-string.gsub"><code>string.gsub</code></a> is called with a function as its
-third argument,
-whenever this function returns <b>nil</b> or <b>false</b> the
-replacement string is the whole match,
-instead of the empty string.
-</li>
-
-<li>
-Function <code>table.setn</code> was deprecated.
-Function <code>table.getn</code> corresponds
-to the new length operator (<code>#</code>);
-use the operator instead of the function.
-(See compile-time option <code>LUA_COMPAT_GETN</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-Function <code>loadlib</code> was renamed <a href="#pdf-package.loadlib"><code>package.loadlib</code></a>.
-(See compile-time option <code>LUA_COMPAT_LOADLIB</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-Function <code>math.mod</code> was renamed <a href="#pdf-math.fmod"><code>math.fmod</code></a>.
-(See compile-time option <code>LUA_COMPAT_MOD</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-Functions <code>table.foreach</code> and <code>table.foreachi</code> are deprecated.
-You can use a for loop with <code>pairs</code> or <code>ipairs</code> instead.
-</li>
-
-<li>
-There were substantial changes in function <a href="#pdf-require"><code>require</code></a> due to
-the new module system.
-However, the new behavior is mostly compatible with the old,
-but <code>require</code> gets the path from <a href="#pdf-package.path"><code>package.path</code></a> instead
-of from <code>LUA_PATH</code>.
-</li>
-
-<li>
-Function <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> has different arguments.
-Function <code>gcinfo</code> is deprecated;
-use <code>collectgarbage("count")</code> instead.
-</li>
-
-</ul>
-
-
-
-
-<h2>7.3 - <a name="7.3">Changes in the API</a></h2>
-<ul>
-
-<li>
-The <code>luaopen_*</code> functions (to open libraries)
-cannot be called directly,
-like a regular C function.
-They must be called through Lua,
-like a Lua function.
-</li>
-
-<li>
-Function <code>lua_open</code> was replaced by <a href="#lua_newstate"><code>lua_newstate</code></a> to
-allow the user to set a memory-allocation function.
-You can use <a href="#luaL_newstate"><code>luaL_newstate</code></a> from the standard library to
-create a state with a standard allocation function
-(based on <code>realloc</code>).
-</li>
-
-<li>
-Functions <code>luaL_getn</code> and <code>luaL_setn</code>
-(from the auxiliary library) are deprecated.
-Use <a href="#lua_objlen"><code>lua_objlen</code></a> instead of <code>luaL_getn</code>
-and nothing instead of <code>luaL_setn</code>.
-</li>
-
-<li>
-Function <code>luaL_openlib</code> was replaced by <a href="#luaL_register"><code>luaL_register</code></a>.
-</li>
-
-<li>
-Function <code>luaL_checkudata</code> now throws an error when the given value
-is not a userdata of the expected type.
-(In Lua&nbsp;5.0 it returned <code>NULL</code>.)
-</li>
-
-</ul>
-
-
-
-
-<h1>8 - <a name="8">The Complete Syntax of Lua</a></h1>
-
-<p>
-Here is the complete syntax of Lua in extended BNF.
-(It does not describe operator precedences.)
-
-
-
-
-<pre>
-
-       chunk ::= {stat [`<b>;</b>&acute;]} [laststat [`<b>;</b>&acute;]]
-
-       block ::= chunk
-
-       stat ::=  varlist `<b>=</b>&acute; explist |
-                functioncall |
-                <b>do</b> block <b>end</b> |
-                <b>while</b> exp <b>do</b> block <b>end</b> |
-                <b>repeat</b> block <b>until</b> exp |
-                <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> |
-                <b>for</b> Name `<b>=</b>&acute; exp `<b>,</b>&acute; exp [`<b>,</b>&acute; exp] <b>do</b> block <b>end</b> |
-                <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> |
-                <b>function</b> funcname funcbody |
-                <b>local</b> <b>function</b> Name funcbody |
-                <b>local</b> namelist [`<b>=</b>&acute; explist]
-
-       laststat ::= <b>return</b> [explist] | <b>break</b>
-
-       funcname ::= Name {`<b>.</b>&acute; Name} [`<b>:</b>&acute; Name]
-
-       varlist ::= var {`<b>,</b>&acute; var}
-
-       var ::=  Name | prefixexp `<b>[</b>&acute; exp `<b>]</b>&acute; | prefixexp `<b>.</b>&acute; Name
-
-       namelist ::= Name {`<b>,</b>&acute; Name}
-
-       explist ::= {exp `<b>,</b>&acute;} exp
-
-       exp ::=  <b>nil</b> | <b>false</b> | <b>true</b> | Number | String | `<b>...</b>&acute; | function |
-                prefixexp | tableconstructor | exp binop exp | unop exp
-
-       prefixexp ::= var | functioncall | `<b>(</b>&acute; exp `<b>)</b>&acute;
-
-       functioncall ::=  prefixexp args | prefixexp `<b>:</b>&acute; Name args
-
-       args ::=  `<b>(</b>&acute; [explist] `<b>)</b>&acute; | tableconstructor | String
-
-       function ::= <b>function</b> funcbody
-
-       funcbody ::= `<b>(</b>&acute; [parlist] `<b>)</b>&acute; block <b>end</b>
-
-       parlist ::= namelist [`<b>,</b>&acute; `<b>...</b>&acute;] | `<b>...</b>&acute;
-
-       tableconstructor ::= `<b>{</b>&acute; [fieldlist] `<b>}</b>&acute;
-
-       fieldlist ::= field {fieldsep field} [fieldsep]
-
-       field ::= `<b>[</b>&acute; exp `<b>]</b>&acute; `<b>=</b>&acute; exp | Name `<b>=</b>&acute; exp | exp
-
-       fieldsep ::= `<b>,</b>&acute; | `<b>;</b>&acute;
-
-       binop ::= `<b>+</b>&acute; | `<b>-</b>&acute; | `<b>*</b>&acute; | `<b>/</b>&acute; | `<b>^</b>&acute; | `<b>%</b>&acute; | `<b>..</b>&acute; |
-                `<b>&lt;</b>&acute; | `<b>&lt;=</b>&acute; | `<b>&gt;</b>&acute; | `<b>&gt;=</b>&acute; | `<b>==</b>&acute; | `<b>~=</b>&acute; |
-                <b>and</b> | <b>or</b>
-
-       unop ::= `<b>-</b>&acute; | <b>not</b> | `<b>#</b>&acute;
-
-</pre>
-
-<p>
-
-
-
-
-
-
-
-<HR>
-<SMALL>
-Last update:
-Mon Aug 18 13:25:46 BRT 2008
-</SMALL>
-<!--
-Last change: revised for Lua 5.1.4
--->
-
-</body></html>

diff --git a/source3/lua-5.1.4/doc/readme.html b/source3/lua-5.1.4/doc/readme.html
deleted file mode 100644 (file)
index 38be6db..0000000
--- a/source3/lua-5.1.4/doc/readme.html
+++ /dev/null
@@ -1,40 +0,0 @@
-<HTML>
-<HEAD>
-<TITLE>Lua documentation</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-</HEAD>
-
-<BODY>
-
-<HR>
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Documentation
-</H1>
-
-This is the documentation included in the source distribution of Lua 5.1.4.
-
-<UL>
-<LI><A HREF="contents.html">Reference manual</A>
-<LI><A HREF="lua.html">lua man page</A>
-<LI><A HREF="luac.html">luac man page</A>
-<LI><A HREF="../README">lua/README</A>
-<LI><A HREF="../etc/README">lua/etc/README</A>
-<LI><A HREF="../test/README">lua/test/README</A>
-</UL>
-
-Lua's
-<A HREF="http://www.lua.org/">official web site</A>
-contains updated documentation,
-especially the
-<A HREF="http://www.lua.org/manual/5.1/">reference manual</A>.
-<P>
-
-<HR>
-<SMALL>
-Last update:
-Tue Aug 12 14:46:07 BRT 2008
-</SMALL>
-
-</BODY>
-</HTML>

diff --git a/source3/lua-5.1.4/etc/Makefile b/source3/lua-5.1.4/etc/Makefile
deleted file mode 100644 (file)
index 20c1479..0000000
--- a/source3/lua-5.1.4/etc/Makefile
+++ /dev/null
@@ -1,44 +0,0 @@
-# makefile for Lua etc
-
-TOP= ..
-LIB= $(TOP)/src
-INC= $(TOP)/src
-BIN= $(TOP)/src
-SRC= $(TOP)/src
-TST= $(TOP)/test
-
-CC= gcc
-CFLAGS= -O2 -Wall -I$(INC) $(MYCFLAGS)
-MYCFLAGS=
-MYLDFLAGS= -Wl,-E
-MYLIBS= -lm
-#MYLIBS= -lm -Wl,-E -ldl -lreadline -lhistory -lncurses
-RM= rm -f
-
-default:
-       @echo 'Please choose a target: min noparser one strict clean'
-
-min:   min.c
-       $(CC) $(CFLAGS) $@.c -L$(LIB) -llua $(MYLIBS)
-       echo 'print"Hello there!"' | ./a.out
-
-noparser: noparser.o
-       $(CC) noparser.o $(SRC)/lua.o -L$(LIB) -llua $(MYLIBS)
-       $(BIN)/luac $(TST)/hello.lua
-       -./a.out luac.out
-       -./a.out -e'a=1'
-
-one:
-       $(CC) $(CFLAGS) all.c $(MYLIBS)
-       ./a.out $(TST)/hello.lua
-
-strict:
-       -$(BIN)/lua -e 'print(a);b=2'
-       -$(BIN)/lua -lstrict -e 'print(a)'
-       -$(BIN)/lua -e 'function f() b=2 end f()'
-       -$(BIN)/lua -lstrict -e 'function f() b=2 end f()'
-
-clean:
-       $(RM) a.out core core.* *.o luac.out
-
-.PHONY:        default min noparser one strict clean

diff --git a/source3/lua-5.1.4/etc/README b/source3/lua-5.1.4/etc/README
deleted file mode 100644 (file)
index c892fe1..0000000
--- a/source3/lua-5.1.4/etc/README
+++ /dev/null
@@ -1,36 +0,0 @@
-This directory contains some useful files and code.
-Unlike the code in ../src, everything here is in the public domain.
-
-If any of the makes fail, you're probably not using the same libraries
-used to build Lua. Set MYLIBS in Makefile accordingly.
-
-all.c
-       Full Lua interpreter in a single file.
-       Do "make one" for a demo.
-
-lua.hpp
-       Lua header files for C++ using 'extern "C"'.
-
-lua.ico
-       A Lua icon for Windows (and web sites: save as favicon.ico).
-       Drawn by hand by Markus Gritsch <gritsch@iue.tuwien.ac.at>.
-
-lua.pc
-       pkg-config data for Lua
-
-luavs.bat
-       Script to build Lua under "Visual Studio .NET Command Prompt".
-       Run it from the toplevel as etc\luavs.bat.
-
-min.c
-       A minimal Lua interpreter.
-       Good for learning and for starting your own.
-       Do "make min" for a demo.
-
-noparser.c
-       Linking with noparser.o avoids loading the parsing modules in lualib.a.
-       Do "make noparser" for a demo.
-
-strict.lua
-       Traps uses of undeclared global variables.
-       Do "make strict" for a demo.

diff --git a/source3/lua-5.1.4/etc/all.c b/source3/lua-5.1.4/etc/all.c
deleted file mode 100644 (file)
index dab68fa..0000000
--- a/source3/lua-5.1.4/etc/all.c
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-* all.c -- Lua core, libraries and interpreter in a single file
-*/
-
-#define luaall_c
-
-#include "lapi.c"
-#include "lcode.c"
-#include "ldebug.c"
-#include "ldo.c"
-#include "ldump.c"
-#include "lfunc.c"
-#include "lgc.c"
-#include "llex.c"
-#include "lmem.c"
-#include "lobject.c"
-#include "lopcodes.c"
-#include "lparser.c"
-#include "lstate.c"
-#include "lstring.c"
-#include "ltable.c"
-#include "ltm.c"
-#include "lundump.c"
-#include "lvm.c"
-#include "lzio.c"
-
-#include "lauxlib.c"
-#include "lbaselib.c"
-#include "ldblib.c"
-#include "liolib.c"
-#include "linit.c"
-#include "lmathlib.c"
-#include "loadlib.c"
-#include "loslib.c"
-#include "lstrlib.c"
-#include "ltablib.c"
-
-#include "lua.c"

diff --git a/source3/lua-5.1.4/etc/lua.hpp b/source3/lua-5.1.4/etc/lua.hpp
deleted file mode 100644 (file)
index ec417f5..0000000
--- a/source3/lua-5.1.4/etc/lua.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// lua.hpp
-// Lua header files for C++
-// <<extern "C">> not supplied automatically because Lua also compiles as C++
-
-extern "C" {
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-}

diff --git a/source3/lua-5.1.4/etc/lua.ico b/source3/lua-5.1.4/etc/lua.ico
deleted file mode 100644 (file)
index ccbabc4..0000000
Binary files a/source3/lua-5.1.4/etc/lua.ico and /dev/null differ

diff --git a/source3/lua-5.1.4/etc/luavs.bat b/source3/lua-5.1.4/etc/luavs.bat
deleted file mode 100644 (file)
index 054b462..0000000
--- a/source3/lua-5.1.4/etc/luavs.bat
+++ /dev/null
@@ -1,28 +0,0 @@
-@rem Script to build Lua under "Visual Studio .NET Command Prompt".
-@rem Do not run from this directory; run it from the toplevel: etc\luavs.bat .
-@rem It creates lua51.dll, lua51.lib, lua.exe, and luac.exe in src.
-@rem (contributed by David Manura and Mike Pall)
-
-@setlocal
-@set MYCOMPILE=cl /nologo /MD /O2 /W3 /c /D_CRT_SECURE_NO_DEPRECATE
-@set MYLINK=link /nologo
-@set MYMT=mt /nologo
-
-cd src
-%MYCOMPILE% /DLUA_BUILD_AS_DLL l*.c
-del lua.obj luac.obj
-%MYLINK% /DLL /out:lua51.dll l*.obj
-if exist lua51.dll.manifest^
-  %MYMT% -manifest lua51.dll.manifest -outputresource:lua51.dll;2
-%MYCOMPILE% /DLUA_BUILD_AS_DLL lua.c
-%MYLINK% /out:lua.exe lua.obj lua51.lib
-if exist lua.exe.manifest^
-  %MYMT% -manifest lua.exe.manifest -outputresource:lua.exe
-%MYCOMPILE% l*.c print.c
-del lua.obj linit.obj lbaselib.obj ldblib.obj liolib.obj lmathlib.obj^
-    loslib.obj ltablib.obj lstrlib.obj loadlib.obj
-%MYLINK% /out:luac.exe *.obj
-if exist luac.exe.manifest^
-  %MYMT% -manifest luac.exe.manifest -outputresource:luac.exe
-del *.obj *.manifest
-cd ..

diff --git a/source3/lua-5.1.4/etc/min.c b/source3/lua-5.1.4/etc/min.c
deleted file mode 100644 (file)
index 6a85a4d..0000000
--- a/source3/lua-5.1.4/etc/min.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-* min.c -- a minimal Lua interpreter
-* loads stdin only with minimal error handling.
-* no interaction, and no standard library, only a "print" function.
-*/
-
-#include <stdio.h>
-
-#include "lua.h"
-#include "lauxlib.h"
-
-static int print(lua_State *L)
-{
- int n=lua_gettop(L);
- int i;
- for (i=1; i<=n; i++)
- {
-  if (i>1) printf("\t");
-  if (lua_isstring(L,i))
-   printf("%s",lua_tostring(L,i));
-  else if (lua_isnil(L,i))
-   printf("%s","nil");
-  else if (lua_isboolean(L,i))
-   printf("%s",lua_toboolean(L,i) ? "true" : "false");
-  else
-   printf("%s:%p",luaL_typename(L,i),lua_topointer(L,i));
- }
- printf("\n");
- return 0;
-}
-
-int main(void)
-{
- lua_State *L=lua_open();
- lua_register(L,"print",print);
- if (luaL_dofile(L,NULL)!=0) fprintf(stderr,"%s\n",lua_tostring(L,-1));
- lua_close(L);
- return 0;
-}

diff --git a/source3/lua-5.1.4/etc/noparser.c b/source3/lua-5.1.4/etc/noparser.c
deleted file mode 100644 (file)
index 13ba546..0000000
--- a/source3/lua-5.1.4/etc/noparser.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-* The code below can be used to make a Lua core that does not contain the
-* parsing modules (lcode, llex, lparser), which represent 35% of the total core.
-* You'll only be able to load binary files and strings, precompiled with luac.
-* (Of course, you'll have to build luac with the original parsing modules!)
-*
-* To use this module, simply compile it ("make noparser" does that) and list
-* its object file before the Lua libraries. The linker should then not load
-* the parsing modules. To try it, do "make luab".
-*
-* If you also want to avoid the dump module (ldump.o), define NODUMP.
-* #define NODUMP
-*/
-
-#define LUA_CORE
-
-#include "llex.h"
-#include "lparser.h"
-#include "lzio.h"
-
-LUAI_FUNC void luaX_init (lua_State *L) {
-  UNUSED(L);
-}
-
-LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
-  UNUSED(z);
-  UNUSED(buff);
-  UNUSED(name);
-  lua_pushliteral(L,"parser not loaded");
-  lua_error(L);
-  return NULL;
-}
-
-#ifdef NODUMP
-#include "lundump.h"
-
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) {
-  UNUSED(f);
-  UNUSED(w);
-  UNUSED(data);
-  UNUSED(strip);
-#if 1
-  UNUSED(L);
-  return 0;
-#else
-  lua_pushliteral(L,"dumper not loaded");
-  lua_error(L);
-#endif
-}
-#endif

diff --git a/source3/lua-5.1.4/etc/strict.lua b/source3/lua-5.1.4/etc/strict.lua
deleted file mode 100644 (file)
index 3ec2ab2..0000000
--- a/source3/lua-5.1.4/etc/strict.lua
+++ /dev/null
@@ -1,40 +0,0 @@
---
--- strict.lua
--- checks uses of undeclared global variables
--- All global variables must be 'declared' through a regular assignment
--- (even assigning nil will do) in a main chunk before being used
--- anywhere or assigned to inside a function.
---
-
-local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget
-
-local mt = getmetatable(_G)
-if mt == nil then
-  mt = {}
-  setmetatable(_G, mt)
-end
-
-mt.__declared = {}
-
-local function what ()
-  local d = getinfo(3, "S")
-  return d and d.what or "C"
-end
-
-mt.__newindex = function (t, n, v)
-  if not mt.__declared[n] then
-    local w = what()
-    if w ~= "main" and w ~= "C" then
-      error("assign to undeclared variable '"..n.."'", 2)
-    end
-    mt.__declared[n] = true
-  end
-  rawset(t, n, v)
-end
-
-mt.__index = function (t, n)
-  if not mt.__declared[n] and what() ~= "C" then
-    error("variable '"..n.."' is not declared", 2)
-  end
-  return rawget(t, n)
-end

diff --git a/source3/lua-5.1.4/src/Makefile b/source3/lua-5.1.4/src/Makefile
deleted file mode 100644 (file)
index e4a3cd6..0000000
--- a/source3/lua-5.1.4/src/Makefile
+++ /dev/null
@@ -1,182 +0,0 @@
-# makefile for building Lua
-# see ../INSTALL for installation instructions
-# see ../Makefile and luaconf.h for further customization
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-CC= gcc
-CFLAGS= -O2 -Wall $(MYCFLAGS)
-AR= ar rcu
-RANLIB= ranlib
-RM= rm -f
-LIBS= -lm $(MYLIBS)
-
-MYCFLAGS=
-MYLDFLAGS=
-MYLIBS=
-
-# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
-
-PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-LUA_A= liblua.a
-CORE_O=        lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
-       lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
-       lundump.o lvm.o lzio.o
-LIB_O= lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
-       lstrlib.o loadlib.o linit.o
-
-LUA_T= lua
-LUA_O= lua.o
-
-LUAC_T=        luac
-LUAC_O=        luac.o print.o
-
-ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
-ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
-ALL_A= $(LUA_A)
-
-default: $(PLAT)
-
-all:   $(ALL_T)
-
-o:     $(ALL_O)
-
-a:     $(ALL_A)
-
-$(LUA_A): $(CORE_O) $(LIB_O)
-       $(AR) $@ $?
-       $(RANLIB) $@
-
-$(LUA_T): $(LUA_O) $(LUA_A)
-       $(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
-
-$(LUAC_T): $(LUAC_O) $(LUA_A)
-       $(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
-
-clean:
-       $(RM) $(ALL_T) $(ALL_O)
-
-depend:
-       @$(CC) $(CFLAGS) -MM l*.c print.c
-
-echo:
-       @echo "PLAT = $(PLAT)"
-       @echo "CC = $(CC)"
-       @echo "CFLAGS = $(CFLAGS)"
-       @echo "AR = $(AR)"
-       @echo "RANLIB = $(RANLIB)"
-       @echo "RM = $(RM)"
-       @echo "MYCFLAGS = $(MYCFLAGS)"
-       @echo "MYLDFLAGS = $(MYLDFLAGS)"
-       @echo "MYLIBS = $(MYLIBS)"
-
-# convenience targets for popular platforms
-
-none:
-       @echo "Please choose a platform:"
-       @echo "   $(PLATS)"
-
-aix:
-       $(MAKE) all CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" MYLDFLAGS="-brtl -bexpall"
-
-ansi:
-       $(MAKE) all MYCFLAGS=-DLUA_ANSI
-
-bsd:
-       $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
-
-freebsd:
-       $(MAKE) all MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -lreadline"
-
-generic:
-       $(MAKE) all MYCFLAGS=
-
-linux:
-       $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
-
-macosx:
-       $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-lreadline"
-# use this on Mac OS X 10.3-
-#      $(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
-
-mingw:
-       $(MAKE) "LUA_A=lua51.dll" "LUA_T=lua.exe" \
-       "AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
-       "MYCFLAGS=-DLUA_BUILD_AS_DLL" "MYLIBS=" "MYLDFLAGS=-s" lua.exe
-       $(MAKE) "LUAC_T=luac.exe" luac.exe
-
-posix:
-       $(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
-
-solaris:
-       $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) default o a clean depend echo none
-
-# DO NOT DELETE
-
-lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
-  lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \
-  lundump.h lvm.h
-lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
-lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
-lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
-  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
-  ltable.h
-ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
-ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
-  llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
-  lfunc.h lstring.h lgc.h ltable.h lvm.h
-ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
-  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \
-  ltable.h lundump.h lvm.h
-ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
-  lzio.h lmem.h lundump.h
-lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
-  lstate.h ltm.h lzio.h
-lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
-  lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
-linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
-liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
-llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
-  lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
-lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
-lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h ldo.h
-loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
-lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
-  ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h
-lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
-loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
-lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
-  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
-  lfunc.h lstring.h lgc.h ltable.h
-lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h
-lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
-  ltm.h lzio.h lstring.h lgc.h
-lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
-ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h
-ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
-ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
-  lmem.h lstring.h lgc.h ltable.h
-lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
-luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
-  lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \
-  lundump.h
-lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
-  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
-lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
-  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
-lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
-  lzio.h
-print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h lopcodes.h lundump.h
-
-# (end of Makefile)

diff --git a/source3/lua-5.1.4/src/lapi.c b/source3/lua-5.1.4/src/lapi.c
deleted file mode 100644 (file)
index dc0275c..0000000
--- a/source3/lua-5.1.4/src/lapi.c
+++ /dev/null
@@ -1,1086 +0,0 @@
-/*
-** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $
-** Lua API
-** See Copyright Notice in lua.h
-*/
-
-
-#include <assert.h>
-#include <math.h>
-#include <stdarg.h>
-#include <string.h>
-
-#define lapi_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lundump.h"
-#include "lvm.h"
-
-
-
-const char lua_ident[] =
-  "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n"
-  "$Authors: " LUA_AUTHORS " $\n"
-  "$URL: www.lua.org $\n";
-
-
-
-#define api_checknelems(L, n)  api_check(L, (n) <= (L->top - L->base))
-
-#define api_checkvalidindex(L, i)      api_check(L, (i) != luaO_nilobject)
-
-#define api_incr_top(L)   {api_check(L, L->top < L->ci->top); L->top++;}
-
-
-
-static TValue *index2adr (lua_State *L, int idx) {
-  if (idx > 0) {
-    TValue *o = L->base + (idx - 1);
-    api_check(L, idx <= L->ci->top - L->base);
-    if (o >= L->top) return cast(TValue *, luaO_nilobject);
-    else return o;
-  }
-  else if (idx > LUA_REGISTRYINDEX) {
-    api_check(L, idx != 0 && -idx <= L->top - L->base);
-    return L->top + idx;
-  }
-  else switch (idx) {  /* pseudo-indices */
-    case LUA_REGISTRYINDEX: return registry(L);
-    case LUA_ENVIRONINDEX: {
-      Closure *func = curr_func(L);
-      sethvalue(L, &L->env, func->c.env);
-      return &L->env;
-    }
-    case LUA_GLOBALSINDEX: return gt(L);
-    default: {
-      Closure *func = curr_func(L);
-      idx = LUA_GLOBALSINDEX - idx;
-      return (idx <= func->c.nupvalues)
-                ? &func->c.upvalue[idx-1]
-                : cast(TValue *, luaO_nilobject);
-    }
-  }
-}
-
-
-static Table *getcurrenv (lua_State *L) {
-  if (L->ci == L->base_ci)  /* no enclosing function? */
-    return hvalue(gt(L));  /* use global table as environment */
-  else {
-    Closure *func = curr_func(L);
-    return func->c.env;
-  }
-}
-
-
-void luaA_pushobject (lua_State *L, const TValue *o) {
-  setobj2s(L, L->top, o);
-  api_incr_top(L);
-}
-
-
-LUA_API int lua_checkstack (lua_State *L, int size) {
-  int res = 1;
-  lua_lock(L);
-  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
-    res = 0;  /* stack overflow */
-  else if (size > 0) {
-    luaD_checkstack(L, size);
-    if (L->ci->top < L->top + size)
-      L->ci->top = L->top + size;
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
-  int i;
-  if (from == to) return;
-  lua_lock(to);
-  api_checknelems(from, n);
-  api_check(from, G(from) == G(to));
-  api_check(from, to->ci->top - to->top >= n);
-  from->top -= n;
-  for (i = 0; i < n; i++) {
-    setobj2s(to, to->top++, from->top + i);
-  }
-  lua_unlock(to);
-}
-
-
-LUA_API void lua_setlevel (lua_State *from, lua_State *to) {
-  to->nCcalls = from->nCcalls;
-}
-
-
-LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
-  lua_CFunction old;
-  lua_lock(L);
-  old = G(L)->panic;
-  G(L)->panic = panicf;
-  lua_unlock(L);
-  return old;
-}
-
-
-LUA_API lua_State *lua_newthread (lua_State *L) {
-  lua_State *L1;
-  lua_lock(L);
-  luaC_checkGC(L);
-  L1 = luaE_newthread(L);
-  setthvalue(L, L->top, L1);
-  api_incr_top(L);
-  lua_unlock(L);
-  luai_userstatethread(L, L1);
-  return L1;
-}
-
-
-
-/*
-** basic stack manipulation
-*/
-
-
-LUA_API int lua_gettop (lua_State *L) {
-  return cast_int(L->top - L->base);
-}
-
-
-LUA_API void lua_settop (lua_State *L, int idx) {
-  lua_lock(L);
-  if (idx >= 0) {
-    api_check(L, idx <= L->stack_last - L->base);
-    while (L->top < L->base + idx)
-      setnilvalue(L->top++);
-    L->top = L->base + idx;
-  }
-  else {
-    api_check(L, -(idx+1) <= (L->top - L->base));
-    L->top += idx+1;  /* `subtract' index (index is negative) */
-  }
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_remove (lua_State *L, int idx) {
-  StkId p;
-  lua_lock(L);
-  p = index2adr(L, idx);
-  api_checkvalidindex(L, p);
-  while (++p < L->top) setobjs2s(L, p-1, p);
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_insert (lua_State *L, int idx) {
-  StkId p;
-  StkId q;
-  lua_lock(L);
-  p = index2adr(L, idx);
-  api_checkvalidindex(L, p);
-  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
-  setobjs2s(L, p, L->top);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_replace (lua_State *L, int idx) {
-  StkId o;
-  lua_lock(L);
-  /* explicit test for incompatible code */
-  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
-    luaG_runerror(L, "no calling environment");
-  api_checknelems(L, 1);
-  o = index2adr(L, idx);
-  api_checkvalidindex(L, o);
-  if (idx == LUA_ENVIRONINDEX) {
-    Closure *func = curr_func(L);
-    api_check(L, ttistable(L->top - 1));
-    func->c.env = hvalue(L->top - 1);
-    luaC_barrier(L, func, L->top - 1);
-  }
-  else {
-    setobj(L, o, L->top - 1);
-    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
-      luaC_barrier(L, curr_func(L), L->top - 1);
-  }
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushvalue (lua_State *L, int idx) {
-  lua_lock(L);
-  setobj2s(L, L->top, index2adr(L, idx));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-
-/*
-** access functions (stack -> C)
-*/
-
-
-LUA_API int lua_type (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);
-}
-
-
-LUA_API const char *lua_typename (lua_State *L, int t) {
-  UNUSED(L);
-  return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
-}
-
-
-LUA_API int lua_iscfunction (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return iscfunction(o);
-}
-
-
-LUA_API int lua_isnumber (lua_State *L, int idx) {
-  TValue n;
-  const TValue *o = index2adr(L, idx);
-  return tonumber(o, &n);
-}
-
-
-LUA_API int lua_isstring (lua_State *L, int idx) {
-  int t = lua_type(L, idx);
-  return (t == LUA_TSTRING || t == LUA_TNUMBER);
-}
-
-
-LUA_API int lua_isuserdata (lua_State *L, int idx) {
-  const TValue *o = index2adr(L, idx);
-  return (ttisuserdata(o) || ttislightuserdata(o));
-}
-
-
-LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
-  StkId o1 = index2adr(L, index1);
-  StkId o2 = index2adr(L, index2);
-  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
-         : luaO_rawequalObj(o1, o2);
-}
-
-
-LUA_API int lua_equal (lua_State *L, int index1, int index2) {
-  StkId o1, o2;
-  int i;
-  lua_lock(L);  /* may call tag method */
-  o1 = index2adr(L, index1);
-  o2 = index2adr(L, index2);
-  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
-  lua_unlock(L);
-  return i;
-}
-
-
-LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
-  StkId o1, o2;
-  int i;
-  lua_lock(L);  /* may call tag method */
-  o1 = index2adr(L, index1);
-  o2 = index2adr(L, index2);
-  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
-       : luaV_lessthan(L, o1, o2);
-  lua_unlock(L);
-  return i;
-}
-
-
-
-LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
-  TValue n;
-  const TValue *o = index2adr(L, idx);
-  if (tonumber(o, &n))
-    return nvalue(o);
-  else
-    return 0;
-}
-
-
-LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
-  TValue n;
-  const TValue *o = index2adr(L, idx);
-  if (tonumber(o, &n)) {
-    lua_Integer res;
-    lua_Number num = nvalue(o);
-    lua_number2integer(res, num);
-    return res;
-  }
-  else
-    return 0;
-}
-
-
-LUA_API int lua_toboolean (lua_State *L, int idx) {
-  const TValue *o = index2adr(L, idx);
-  return !l_isfalse(o);
-}
-
-
-LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
-  StkId o = index2adr(L, idx);
-  if (!ttisstring(o)) {
-    lua_lock(L);  /* `luaV_tostring' may create a new string */
-    if (!luaV_tostring(L, o)) {  /* conversion failed? */
-      if (len != NULL) *len = 0;
-      lua_unlock(L);
-      return NULL;
-    }
-    luaC_checkGC(L);
-    o = index2adr(L, idx);  /* previous call may reallocate the stack */
-    lua_unlock(L);
-  }
-  if (len != NULL) *len = tsvalue(o)->len;
-  return svalue(o);
-}
-
-
-LUA_API size_t lua_objlen (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TSTRING: return tsvalue(o)->len;
-    case LUA_TUSERDATA: return uvalue(o)->len;
-    case LUA_TTABLE: return luaH_getn(hvalue(o));
-    case LUA_TNUMBER: {
-      size_t l;
-      lua_lock(L);  /* `luaV_tostring' may create a new string */
-      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
-      lua_unlock(L);
-      return l;
-    }
-    default: return 0;
-  }
-}
-
-
-LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
-}
-
-
-LUA_API void *lua_touserdata (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
-    case LUA_TLIGHTUSERDATA: return pvalue(o);
-    default: return NULL;
-  }
-}
-
-
-LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return (!ttisthread(o)) ? NULL : thvalue(o);
-}
-
-
-LUA_API const void *lua_topointer (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TTABLE: return hvalue(o);
-    case LUA_TFUNCTION: return clvalue(o);
-    case LUA_TTHREAD: return thvalue(o);
-    case LUA_TUSERDATA:
-    case LUA_TLIGHTUSERDATA:
-      return lua_touserdata(L, idx);
-    default: return NULL;
-  }
-}
-
-
-
-/*
-** push functions (C -> stack)
-*/
-
-
-LUA_API void lua_pushnil (lua_State *L) {
-  lua_lock(L);
-  setnilvalue(L->top);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
-  lua_lock(L);
-  setnvalue(L->top, n);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
-  lua_lock(L);
-  setnvalue(L->top, cast_num(n));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
-  lua_lock(L);
-  luaC_checkGC(L);
-  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushstring (lua_State *L, const char *s) {
-  if (s == NULL)
-    lua_pushnil(L);
-  else
-    lua_pushlstring(L, s, strlen(s));
-}
-
-
-LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
-                                      va_list argp) {
-  const char *ret;
-  lua_lock(L);
-  luaC_checkGC(L);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
-  const char *ret;
-  va_list argp;
-  lua_lock(L);
-  luaC_checkGC(L);
-  va_start(argp, fmt);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
-  Closure *cl;
-  lua_lock(L);
-  luaC_checkGC(L);
-  api_checknelems(L, n);
-  cl = luaF_newCclosure(L, n, getcurrenv(L));
-  cl->c.f = fn;
-  L->top -= n;
-  while (n--)
-    setobj2n(L, &cl->c.upvalue[n], L->top+n);
-  setclvalue(L, L->top, cl);
-  lua_assert(iswhite(obj2gco(cl)));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushboolean (lua_State *L, int b) {
-  lua_lock(L);
-  setbvalue(L->top, (b != 0));  /* ensure that true is 1 */
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
-  lua_lock(L);
-  setpvalue(L->top, p);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_pushthread (lua_State *L) {
-  lua_lock(L);
-  setthvalue(L, L->top, L);
-  api_incr_top(L);
-  lua_unlock(L);
-  return (G(L)->mainthread == L);
-}
-
-
-
-/*
-** get functions (Lua -> stack)
-*/
-
-
-LUA_API void lua_gettable (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  luaV_gettable(L, t, L->top - 1, L->top - 1);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_gettable(L, t, &key, L->top);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawget (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_check(L, ttistable(t));
-  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
-  StkId o;
-  lua_lock(L);
-  o = index2adr(L, idx);
-  api_check(L, ttistable(o));
-  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
-  lua_lock(L);
-  luaC_checkGC(L);
-  sethvalue(L, L->top, luaH_new(L, narray, nrec));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_getmetatable (lua_State *L, int objindex) {
-  const TValue *obj;
-  Table *mt = NULL;
-  int res;
-  lua_lock(L);
-  obj = index2adr(L, objindex);
-  switch (ttype(obj)) {
-    case LUA_TTABLE:
-      mt = hvalue(obj)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(obj)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttype(obj)];
-      break;
-  }
-  if (mt == NULL)
-    res = 0;
-  else {
-    sethvalue(L, L->top, mt);
-    api_incr_top(L);
-    res = 1;
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API void lua_getfenv (lua_State *L, int idx) {
-  StkId o;
-  lua_lock(L);
-  o = index2adr(L, idx);
-  api_checkvalidindex(L, o);
-  switch (ttype(o)) {
-    case LUA_TFUNCTION:
-      sethvalue(L, L->top, clvalue(o)->c.env);
-      break;
-    case LUA_TUSERDATA:
-      sethvalue(L, L->top, uvalue(o)->env);
-      break;
-    case LUA_TTHREAD:
-      setobj2s(L, L->top,  gt(thvalue(o)));
-      break;
-    default:
-      setnilvalue(L->top);
-      break;
-  }
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-/*
-** set functions (stack -> Lua)
-*/
-
-
-LUA_API void lua_settable (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  luaV_settable(L, t, L->top - 2, L->top - 1);
-  L->top -= 2;  /* pop index and value */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_settable(L, t, &key, L->top - 1);
-  L->top--;  /* pop value */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawset (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  t = index2adr(L, idx);
-  api_check(L, ttistable(t));
-  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
-  luaC_barriert(L, hvalue(t), L->top-1);
-  L->top -= 2;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
-  StkId o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2adr(L, idx);
-  api_check(L, ttistable(o));
-  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
-  luaC_barriert(L, hvalue(o), L->top-1);
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_setmetatable (lua_State *L, int objindex) {
-  TValue *obj;
-  Table *mt;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  obj = index2adr(L, objindex);
-  api_checkvalidindex(L, obj);
-  if (ttisnil(L->top - 1))
-    mt = NULL;
-  else {
-    api_check(L, ttistable(L->top - 1));
-    mt = hvalue(L->top - 1);
-  }
-  switch (ttype(obj)) {
-    case LUA_TTABLE: {
-      hvalue(obj)->metatable = mt;
-      if (mt)
-        luaC_objbarriert(L, hvalue(obj), mt);
-      break;
-    }
-    case LUA_TUSERDATA: {
-      uvalue(obj)->metatable = mt;
-      if (mt)
-        luaC_objbarrier(L, rawuvalue(obj), mt);
-      break;
-    }
-    default: {
-      G(L)->mt[ttype(obj)] = mt;
-      break;
-    }
-  }
-  L->top--;
-  lua_unlock(L);
-  return 1;
-}
-
-
-LUA_API int lua_setfenv (lua_State *L, int idx) {
-  StkId o;
-  int res = 1;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2adr(L, idx);
-  api_checkvalidindex(L, o);
-  api_check(L, ttistable(L->top - 1));
-  switch (ttype(o)) {
-    case LUA_TFUNCTION:
-      clvalue(o)->c.env = hvalue(L->top - 1);
-      break;
-    case LUA_TUSERDATA:
-      uvalue(o)->env = hvalue(L->top - 1);
-      break;
-    case LUA_TTHREAD:
-      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
-      break;
-    default:
-      res = 0;
-      break;
-  }
-  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
-  L->top--;
-  lua_unlock(L);
-  return res;
-}
-
-
-/*
-** `load' and `call' functions (run Lua code)
-*/
-
-
-#define adjustresults(L,nres) \
-    { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }
-
-
-#define checkresults(L,na,nr) \
-     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))
-
-
-LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
-  StkId func;
-  lua_lock(L);
-  api_checknelems(L, nargs+1);
-  checkresults(L, nargs, nresults);
-  func = L->top - (nargs+1);
-  luaD_call(L, func, nresults);
-  adjustresults(L, nresults);
-  lua_unlock(L);
-}
-
-
-
-/*
-** Execute a protected call.
-*/
-struct CallS {  /* data to `f_call' */
-  StkId func;
-  int nresults;
-};
-
-
-static void f_call (lua_State *L, void *ud) {
-  struct CallS *c = cast(struct CallS *, ud);
-  luaD_call(L, c->func, c->nresults);
-}
-
-
-
-LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
-  struct CallS c;
-  int status;
-  ptrdiff_t func;
-  lua_lock(L);
-  api_checknelems(L, nargs+1);
-  checkresults(L, nargs, nresults);
-  if (errfunc == 0)
-    func = 0;
-  else {
-    StkId o = index2adr(L, errfunc);
-    api_checkvalidindex(L, o);
-    func = savestack(L, o);
-  }
-  c.func = L->top - (nargs+1);  /* function to be called */
-  c.nresults = nresults;
-  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
-  adjustresults(L, nresults);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** Execute a protected C call.
-*/
-struct CCallS {  /* data to `f_Ccall' */
-  lua_CFunction func;
-  void *ud;
-};
-
-
-static void f_Ccall (lua_State *L, void *ud) {
-  struct CCallS *c = cast(struct CCallS *, ud);
-  Closure *cl;
-  cl = luaF_newCclosure(L, 0, getcurrenv(L));
-  cl->c.f = c->func;
-  setclvalue(L, L->top, cl);  /* push function */
-  api_incr_top(L);
-  setpvalue(L->top, c->ud);  /* push only argument */
-  api_incr_top(L);
-  luaD_call(L, L->top - 2, 0);
-}
-
-
-LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
-  struct CCallS c;
-  int status;
-  lua_lock(L);
-  c.func = func;
-  c.ud = ud;
-  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
-                      const char *chunkname) {
-  ZIO z;
-  int status;
-  lua_lock(L);
-  if (!chunkname) chunkname = "?";
-  luaZ_init(L, &z, reader, data);
-  status = luaD_protectedparser(L, &z, chunkname);
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
-  int status;
-  TValue *o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = L->top - 1;
-  if (isLfunction(o))
-    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
-  else
-    status = 1;
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int  lua_status (lua_State *L) {
-  return L->status;
-}
-
-
-/*
-** Garbage-collection function
-*/
-
-LUA_API int lua_gc (lua_State *L, int what, int data) {
-  int res = 0;
-  global_State *g;
-  lua_lock(L);
-  g = G(L);
-  switch (what) {
-    case LUA_GCSTOP: {
-      g->GCthreshold = MAX_LUMEM;
-      break;
-    }
-    case LUA_GCRESTART: {
-      g->GCthreshold = g->totalbytes;
-      break;
-    }
-    case LUA_GCCOLLECT: {
-      luaC_fullgc(L);
-      break;
-    }
-    case LUA_GCCOUNT: {
-      /* GC values are expressed in Kbytes: #bytes/2^10 */
-      res = cast_int(g->totalbytes >> 10);
-      break;
-    }
-    case LUA_GCCOUNTB: {
-      res = cast_int(g->totalbytes & 0x3ff);
-      break;
-    }
-    case LUA_GCSTEP: {
-      lu_mem a = (cast(lu_mem, data) << 10);
-      if (a <= g->totalbytes)
-        g->GCthreshold = g->totalbytes - a;
-      else
-        g->GCthreshold = 0;
-      while (g->GCthreshold <= g->totalbytes) {
-        luaC_step(L);
-        if (g->gcstate == GCSpause) {  /* end of cycle? */
-          res = 1;  /* signal it */
-          break;
-        }
-      }
-      break;
-    }
-    case LUA_GCSETPAUSE: {
-      res = g->gcpause;
-      g->gcpause = data;
-      break;
-    }
-    case LUA_GCSETSTEPMUL: {
-      res = g->gcstepmul;
-      g->gcstepmul = data;
-      break;
-    }
-    default: res = -1;  /* invalid option */
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-
-/*
-** miscellaneous functions
-*/
-
-
-LUA_API int lua_error (lua_State *L) {
-  lua_lock(L);
-  api_checknelems(L, 1);
-  luaG_errormsg(L);
-  lua_unlock(L);
-  return 0;  /* to avoid warnings */
-}
-
-
-LUA_API int lua_next (lua_State *L, int idx) {
-  StkId t;
-  int more;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_check(L, ttistable(t));
-  more = luaH_next(L, hvalue(t), L->top - 1);
-  if (more) {
-    api_incr_top(L);
-  }
-  else  /* no more elements */
-    L->top -= 1;  /* remove key */
-  lua_unlock(L);
-  return more;
-}
-
-
-LUA_API void lua_concat (lua_State *L, int n) {
-  lua_lock(L);
-  api_checknelems(L, n);
-  if (n >= 2) {
-    luaC_checkGC(L);
-    luaV_concat(L, n, cast_int(L->top - L->base) - 1);
-    L->top -= (n-1);
-  }
-  else if (n == 0) {  /* push empty string */
-    setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
-    api_incr_top(L);
-  }
-  /* else n == 1; nothing to do */
-  lua_unlock(L);
-}
-
-
-LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
-  lua_Alloc f;
-  lua_lock(L);
-  if (ud) *ud = G(L)->ud;
-  f = G(L)->frealloc;
-  lua_unlock(L);
-  return f;
-}
-
-
-LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
-  lua_lock(L);
-  G(L)->ud = ud;
-  G(L)->frealloc = f;
-  lua_unlock(L);
-}
-
-
-LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
-  Udata *u;
-  lua_lock(L);
-  luaC_checkGC(L);
-  u = luaS_newudata(L, size, getcurrenv(L));
-  setuvalue(L, L->top, u);
-  api_incr_top(L);
-  lua_unlock(L);
-  return u + 1;
-}
-
-
-
-
-static const char *aux_upvalue (StkId fi, int n, TValue **val) {
-  Closure *f;
-  if (!ttisfunction(fi)) return NULL;
-  f = clvalue(fi);
-  if (f->c.isC) {
-    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
-    *val = &f->c.upvalue[n-1];
-    return "";
-  }
-  else {
-    Proto *p = f->l.p;
-    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
-    *val = f->l.upvals[n-1]->v;
-    return getstr(p->upvalues[n-1]);
-  }
-}
-
-
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val;
-  lua_lock(L);
-  name = aux_upvalue(index2adr(L, funcindex), n, &val);
-  if (name) {
-    setobj2s(L, L->top, val);
-    api_incr_top(L);
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val;
-  StkId fi;
-  lua_lock(L);
-  fi = index2adr(L, funcindex);
-  api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val);
-  if (name) {
-    L->top--;
-    setobj(L, val, L->top);
-    luaC_barrier(L, clvalue(fi), L->top);
-  }
-  lua_unlock(L);
-  return name;
-}

diff --git a/source3/lua-5.1.4/src/lapi.h b/source3/lua-5.1.4/src/lapi.h
deleted file mode 100644 (file)
index 2c3fab2..0000000
--- a/source3/lua-5.1.4/src/lapi.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions from Lua API
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lapi_h
-#define lapi_h
-
-
-#include "lobject.h"
-
-
-LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
-
-#endif

diff --git a/source3/lua-5.1.4/src/lauxlib.c b/source3/lua-5.1.4/src/lauxlib.c
deleted file mode 100644 (file)
index faf6e6c..0000000
--- a/source3/lua-5.1.4/src/lauxlib.c
+++ /dev/null
@@ -1,651 +0,0 @@
-/*
-** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#include <ctype.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/* This file uses only the official API of Lua.
-** Any function declared here could be written as an application function.
-*/
-
-#define lauxlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-
-
-#define FREELIST_REF   0       /* free list of references */
-
-
-/* convert a stack index to positive */
-#define abs_index(L, i)                ((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
-                                       lua_gettop(L) + (i) + 1)
-
-
-/*
-** {======================================================
-** Error-report functions
-** =======================================================
-*/
-
-
-LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
-  lua_Debug ar;
-  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
-  lua_getinfo(L, "n", &ar);
-  if (strcmp(ar.namewhat, "method") == 0) {
-    narg--;  /* do not count `self' */
-    if (narg == 0)  /* error is in the self argument itself? */
-      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
-                           ar.name, extramsg);
-  }
-  if (ar.name == NULL)
-    ar.name = "?";
-  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
-                        narg, ar.name, extramsg);
-}
-
-
-LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
-  const char *msg = lua_pushfstring(L, "%s expected, got %s",
-                                    tname, luaL_typename(L, narg));
-  return luaL_argerror(L, narg, msg);
-}
-
-
-static void tag_error (lua_State *L, int narg, int tag) {
-  luaL_typerror(L, narg, lua_typename(L, tag));
-}
-
-
-LUALIB_API void luaL_where (lua_State *L, int level) {
-  lua_Debug ar;
-  if (lua_getstack(L, level, &ar)) {  /* check function at level */
-    lua_getinfo(L, "Sl", &ar);  /* get info about it */
-    if (ar.currentline > 0) {  /* is there info? */
-      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
-      return;
-    }
-  }
-  lua_pushliteral(L, "");  /* else, no information available... */
-}
-
-
-LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
-  va_list argp;
-  va_start(argp, fmt);
-  luaL_where(L, 1);
-  lua_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  lua_concat(L, 2);
-  return lua_error(L);
-}
-
-/* }====================================================== */
-
-
-LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
-                                 const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, narg, def) :
-                             luaL_checkstring(L, narg);
-  int i;
-  for (i=0; lst[i]; i++)
-    if (strcmp(lst[i], name) == 0)
-      return i;
-  return luaL_argerror(L, narg,
-                       lua_pushfstring(L, "invalid option " LUA_QS, name));
-}
-
-
-LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
-  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
-  if (!lua_isnil(L, -1))  /* name already in use? */
-    return 0;  /* leave previous value on top, but return 0 */
-  lua_pop(L, 1);
-  lua_newtable(L);  /* create metatable */
-  lua_pushvalue(L, -1);
-  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
-  return 1;
-}
-
-
-LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
-  void *p = lua_touserdata(L, ud);
-  if (p != NULL) {  /* value is a userdata? */
-    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
-      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
-      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
-        lua_pop(L, 2);  /* remove both metatables */
-        return p;
-      }
-    }
-  }
-  luaL_typerror(L, ud, tname);  /* else error */
-  return NULL;  /* to avoid warnings */
-}
-
-
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
-  if (!lua_checkstack(L, space))
-    luaL_error(L, "stack overflow (%s)", mes);
-}
-
-
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
-  if (lua_type(L, narg) != t)
-    tag_error(L, narg, t);
-}
-
-
-LUALIB_API void luaL_checkany (lua_State *L, int narg) {
-  if (lua_type(L, narg) == LUA_TNONE)
-    luaL_argerror(L, narg, "value expected");
-}
-
-
-LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
-  const char *s = lua_tolstring(L, narg, len);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
-  return s;
-}
-
-
-LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
-                                        const char *def, size_t *len) {
-  if (lua_isnoneornil(L, narg)) {
-    if (len)
-      *len = (def ? strlen(def) : 0);
-    return def;
-  }
-  else return luaL_checklstring(L, narg, len);
-}
-
-
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
-  lua_Number d = lua_tonumber(L, narg);
-  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, narg, def);
-}
-
-
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
-  lua_Integer d = lua_tointeger(L, narg);
-  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
-                                                      lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, narg, def);
-}
-
-
-LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
-  if (!lua_getmetatable(L, obj))  /* no metatable? */
-    return 0;
-  lua_pushstring(L, event);
-  lua_rawget(L, -2);
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 2);  /* remove metatable and metafield */
-    return 0;
-  }
-  else {
-    lua_remove(L, -2);  /* remove only metatable */
-    return 1;
-  }
-}
-
-
-LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
-  obj = abs_index(L, obj);
-  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
-    return 0;
-  lua_pushvalue(L, obj);
-  lua_call(L, 1, 1);
-  return 1;
-}
-
-
-LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
-                                const luaL_Reg *l) {
-  luaI_openlib(L, libname, l, 0);
-}
-
-
-static int libsize (const luaL_Reg *l) {
-  int size = 0;
-  for (; l->name; l++) size++;
-  return size;
-}
-
-
-LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
-                              const luaL_Reg *l, int nup) {
-  if (libname) {
-    int size = libsize(l);
-    /* check whether lib already exists */
-    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
-    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
-    if (!lua_istable(L, -1)) {  /* not found? */
-      lua_pop(L, 1);  /* remove previous result */
-      /* try global variable (and create one if it does not exist) */
-      if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
-        luaL_error(L, "name conflict for module " LUA_QS, libname);
-      lua_pushvalue(L, -1);
-      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */
-    }
-    lua_remove(L, -2);  /* remove _LOADED table */
-    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
-  }
-  for (; l->name; l++) {
-    int i;
-    for (i=0; i<nup; i++)  /* copy upvalues to the top */
-      lua_pushvalue(L, -nup);
-    lua_pushcclosure(L, l->func, nup);
-    lua_setfield(L, -(nup+2), l->name);
-  }
-  lua_pop(L, nup);  /* remove upvalues */
-}
-
-
-
-/*
-** {======================================================
-** getn-setn: size for arrays
-** =======================================================
-*/
-
-#if defined(LUA_COMPAT_GETN)
-
-static int checkint (lua_State *L, int topop) {
-  int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;
-  lua_pop(L, topop);
-  return n;
-}
-
-
-static void getsizes (lua_State *L) {
-  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");
-  if (lua_isnil(L, -1)) {  /* no `size' table? */
-    lua_pop(L, 1);  /* remove nil */
-    lua_newtable(L);  /* create it */
-    lua_pushvalue(L, -1);  /* `size' will be its own metatable */
-    lua_setmetatable(L, -2);
-    lua_pushliteral(L, "kv");
-    lua_setfield(L, -2, "__mode");  /* metatable(N).__mode = "kv" */
-    lua_pushvalue(L, -1);
-    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");  /* store in register */
-  }
-}
-
-
-LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
-  t = abs_index(L, t);
-  lua_pushliteral(L, "n");
-  lua_rawget(L, t);
-  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */
-    lua_pushliteral(L, "n");  /* use it */
-    lua_pushinteger(L, n);
-    lua_rawset(L, t);
-  }
-  else {  /* use `sizes' */
-    getsizes(L);
-    lua_pushvalue(L, t);
-    lua_pushinteger(L, n);
-    lua_rawset(L, -3);  /* sizes[t] = n */
-    lua_pop(L, 1);  /* remove `sizes' */
-  }
-}
-
-
-LUALIB_API int luaL_getn (lua_State *L, int t) {
-  int n;
-  t = abs_index(L, t);
-  lua_pushliteral(L, "n");  /* try t.n */
-  lua_rawget(L, t);
-  if ((n = checkint(L, 1)) >= 0) return n;
-  getsizes(L);  /* else try sizes[t] */
-  lua_pushvalue(L, t);
-  lua_rawget(L, -2);
-  if ((n = checkint(L, 2)) >= 0) return n;
-  return (int)lua_objlen(L, t);
-}
-
-#endif
-
-/* }====================================================== */
-
-
-
-LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
-                                                               const char *r) {
-  const char *wild;
-  size_t l = strlen(p);
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while ((wild = strstr(s, p)) != NULL) {
-    luaL_addlstring(&b, s, wild - s);  /* push prefix */
-    luaL_addstring(&b, r);  /* push replacement in place of pattern */
-    s = wild + l;  /* continue after `p' */
-  }
-  luaL_addstring(&b, s);  /* push last suffix */
-  luaL_pushresult(&b);
-  return lua_tostring(L, -1);
-}
-
-
-LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
-                                       const char *fname, int szhint) {
-  const char *e;
-  lua_pushvalue(L, idx);
-  do {
-    e = strchr(fname, '.');
-    if (e == NULL) e = fname + strlen(fname);
-    lua_pushlstring(L, fname, e - fname);
-    lua_rawget(L, -2);
-    if (lua_isnil(L, -1)) {  /* no such field? */
-      lua_pop(L, 1);  /* remove this nil */
-      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
-      lua_pushlstring(L, fname, e - fname);
-      lua_pushvalue(L, -2);
-      lua_settable(L, -4);  /* set new table into field */
-    }
-    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
-      lua_pop(L, 2);  /* remove table and value */
-      return fname;  /* return problematic part of the name */
-    }
-    lua_remove(L, -2);  /* remove previous table */
-    fname = e + 1;
-  } while (*e == '.');
-  return NULL;
-}
-
-
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-
-#define bufflen(B)     ((B)->p - (B)->buffer)
-#define bufffree(B)    ((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
-
-#define LIMIT  (LUA_MINSTACK/2)
-
-
-static int emptybuffer (luaL_Buffer *B) {
-  size_t l = bufflen(B);
-  if (l == 0) return 0;  /* put nothing on stack */
-  else {
-    lua_pushlstring(B->L, B->buffer, l);
-    B->p = B->buffer;
-    B->lvl++;
-    return 1;
-  }
-}
-
-
-static void adjuststack (luaL_Buffer *B) {
-  if (B->lvl > 1) {
-    lua_State *L = B->L;
-    int toget = 1;  /* number of levels to concat */
-    size_t toplen = lua_strlen(L, -1);
-    do {
-      size_t l = lua_strlen(L, -(toget+1));
-      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
-        toplen += l;
-        toget++;
-      }
-      else break;
-    } while (toget < B->lvl);
-    lua_concat(L, toget);
-    B->lvl = B->lvl - toget + 1;
-  }
-}
-
-
-LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
-  if (emptybuffer(B))
-    adjuststack(B);
-  return B->buffer;
-}
-
-
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  while (l--)
-    luaL_addchar(B, *s++);
-}
-
-
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
-  luaL_addlstring(B, s, strlen(s));
-}
-
-
-LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
-  emptybuffer(B);
-  lua_concat(B->L, B->lvl);
-  B->lvl = 1;
-}
-
-
-LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
-  lua_State *L = B->L;
-  size_t vl;
-  const char *s = lua_tolstring(L, -1, &vl);
-  if (vl <= bufffree(B)) {  /* fit into buffer? */
-    memcpy(B->p, s, vl);  /* put it there */
-    B->p += vl;
-    lua_pop(L, 1);  /* remove from stack */
-  }
-  else {
-    if (emptybuffer(B))
-      lua_insert(L, -2);  /* put buffer before new value */
-    B->lvl++;  /* add new value into B stack */
-    adjuststack(B);
-  }
-}
-
-
-LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
-  B->L = L;
-  B->p = B->buffer;
-  B->lvl = 0;
-}
-
-/* }====================================================== */
-
-
-LUALIB_API int luaL_ref (lua_State *L, int t) {
-  int ref;
-  t = abs_index(L, t);
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 1);  /* remove from stack */
-    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
-  }
-  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
-  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
-  lua_pop(L, 1);  /* remove it from stack */
-  if (ref != 0) {  /* any free element? */
-    lua_rawgeti(L, t, ref);  /* remove it from list */
-    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
-  }
-  else {  /* no free elements */
-    ref = (int)lua_objlen(L, t);
-    ref++;  /* create new reference */
-  }
-  lua_rawseti(L, t, ref);
-  return ref;
-}
-
-
-LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
-  if (ref >= 0) {
-    t = abs_index(L, t);
-    lua_rawgeti(L, t, FREELIST_REF);
-    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
-    lua_pushinteger(L, ref);
-    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
-  }
-}
-
-
-
-/*
-** {======================================================
-** Load functions
-** =======================================================
-*/
-
-typedef struct LoadF {
-  int extraline;
-  FILE *f;
-  char buff[LUAL_BUFFERSIZE];
-} LoadF;
-
-
-static const char *getF (lua_State *L, void *ud, size_t *size) {
-  LoadF *lf = (LoadF *)ud;
-  (void)L;
-  if (lf->extraline) {
-    lf->extraline = 0;
-    *size = 1;
-    return "\n";
-  }
-  if (feof(lf->f)) return NULL;
-  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
-  return (*size > 0) ? lf->buff : NULL;
-}
-
-
-static int errfile (lua_State *L, const char *what, int fnameindex) {
-  const char *serr = strerror(errno);
-  const char *filename = lua_tostring(L, fnameindex) + 1;
-  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
-  lua_remove(L, fnameindex);
-  return LUA_ERRFILE;
-}
-
-
-LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
-  LoadF lf;
-  int status, readstatus;
-  int c;
-  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
-  lf.extraline = 0;
-  if (filename == NULL) {
-    lua_pushliteral(L, "=stdin");
-    lf.f = stdin;
-  }
-  else {
-    lua_pushfstring(L, "@%s", filename);
-    lf.f = fopen(filename, "r");
-    if (lf.f == NULL) return errfile(L, "open", fnameindex);
-  }
-  c = getc(lf.f);
-  if (c == '#') {  /* Unix exec. file? */
-    lf.extraline = 1;
-    while ((c = getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */
-    if (c == '\n') c = getc(lf.f);
-  }
-  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
-    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
-    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
-    /* skip eventual `#!...' */
-   while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
-    lf.extraline = 0;
-  }
-  ungetc(c, lf.f);
-  status = lua_load(L, getF, &lf, lua_tostring(L, -1));
-  readstatus = ferror(lf.f);
-  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
-  if (readstatus) {
-    lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
-    return errfile(L, "read", fnameindex);
-  }
-  lua_remove(L, fnameindex);
-  return status;
-}
-
-
-typedef struct LoadS {
-  const char *s;
-  size_t size;
-} LoadS;
-
-
-static const char *getS (lua_State *L, void *ud, size_t *size) {
-  LoadS *ls = (LoadS *)ud;
-  (void)L;
-  if (ls->size == 0) return NULL;
-  *size = ls->size;
-  ls->size = 0;
-  return ls->s;
-}
-
-
-LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
-                                const char *name) {
-  LoadS ls;
-  ls.s = buff;
-  ls.size = size;
-  return lua_load(L, getS, &ls, name);
-}
-
-
-LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {
-  return luaL_loadbuffer(L, s, strlen(s), s);
-}
-
-
-
-/* }====================================================== */
-
-
-static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
-  (void)ud;
-  (void)osize;
-  if (nsize == 0) {
-    free(ptr);
-    return NULL;
-  }
-  else
-    return realloc(ptr, nsize);
-}
-
-
-static int panic (lua_State *L) {
-  (void)L;  /* to avoid warnings */
-  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
-                   lua_tostring(L, -1));
-  return 0;
-}
-
-
-LUALIB_API lua_State *luaL_newstate (void) {
-  lua_State *L = lua_newstate(l_alloc, NULL);
-  if (L) lua_atpanic(L, &panic);
-  return L;
-}

diff --git a/source3/lua-5.1.4/src/lauxlib.h b/source3/lua-5.1.4/src/lauxlib.h
deleted file mode 100644 (file)
index 0320410..0000000
--- a/source3/lua-5.1.4/src/lauxlib.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lauxlib_h
-#define lauxlib_h
-
-
-#include <stddef.h>
-#include <stdio.h>
-
-#include "lua.h"
-
-
-#if defined(LUA_COMPAT_GETN)
-LUALIB_API int (luaL_getn) (lua_State *L, int t);
-LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
-#else
-#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
-#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
-#endif
-
-#if defined(LUA_COMPAT_OPENLIB)
-#define luaI_openlib   luaL_openlib
-#endif
-
-
-/* extra error code for `luaL_load' */
-#define LUA_ERRFILE     (LUA_ERRERR+1)
-
-
-typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;
-
-
-
-LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
-                                const luaL_Reg *l, int nup);
-LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
-                                const luaL_Reg *l);
-LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
-LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
-LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
-LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
-LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
-                                                          size_t *l);
-LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
-                                          const char *def, size_t *l);
-LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
-LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
-
-LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
-LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
-                                          lua_Integer def);
-
-LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
-LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
-LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
-
-LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
-LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
-
-LUALIB_API void (luaL_where) (lua_State *L, int lvl);
-LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
-
-LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
-                                   const char *const lst[]);
-
-LUALIB_API int (luaL_ref) (lua_State *L, int t);
-LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
-
-LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
-LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
-                                  const char *name);
-LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
-
-LUALIB_API lua_State *(luaL_newstate) (void);
-
-
-LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
-                                                  const char *r);
-
-LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
-                                         const char *fname, int szhint);
-
-
-
-
-/*
-** ===============================================================
-** some useful macros
-** ===============================================================
-*/
-
-#define luaL_argcheck(L, cond,numarg,extramsg) \
-               ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
-#define luaL_checkstring(L,n)  (luaL_checklstring(L, (n), NULL))
-#define luaL_optstring(L,n,d)  (luaL_optlstring(L, (n), (d), NULL))
-#define luaL_checkint(L,n)     ((int)luaL_checkinteger(L, (n)))
-#define luaL_optint(L,n,d)     ((int)luaL_optinteger(L, (n), (d)))
-#define luaL_checklong(L,n)    ((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)    ((long)luaL_optinteger(L, (n), (d)))
-
-#define luaL_typename(L,i)     lua_typename(L, lua_type(L,(i)))
-
-#define luaL_dofile(L, fn) \
-       (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
-
-#define luaL_dostring(L, s) \
-       (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
-
-#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
-
-#define luaL_opt(L,f,n,d)      (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-
-
-typedef struct luaL_Buffer {
-  char *p;                     /* current position in buffer */
-  int lvl;  /* number of strings in the stack (level) */
-  lua_State *L;
-  char buffer[LUAL_BUFFERSIZE];
-} luaL_Buffer;
-
-#define luaL_addchar(B,c) \
-  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
-   (*(B)->p++ = (char)(c)))
-
-/* compatibility only */
-#define luaL_putchar(B,c)      luaL_addchar(B,c)
-
-#define luaL_addsize(B,n)      ((B)->p += (n))
-
-LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
-LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
-LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
-LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
-LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
-LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
-
-
-/* }====================================================== */
-
-
-/* compatibility with ref system */
-
-/* pre-defined references */
-#define LUA_NOREF       (-2)
-#define LUA_REFNIL      (-1)
-
-#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
-      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
-
-#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
-
-#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
-
-
-#define luaL_reg       luaL_Reg
-
-#endif

diff --git a/source3/lua-5.1.4/src/lbaselib.c b/source3/lua-5.1.4/src/lbaselib.c
deleted file mode 100644 (file)
index 0ec1499..0000000
--- a/source3/lua-5.1.4/src/lbaselib.c
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
-** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
-** Basic library
-** See Copyright Notice in lua.h
-*/
-
-
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lbaselib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-
-/*
-** If your system does not support `stdout', you can just remove this function.
-** If you need, you can define your own `print' function, following this
-** model but changing `fputs' to put the strings at a proper place
-** (a console window or a log file, for instance).
-*/
-static int luaB_print (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  lua_getglobal(L, "tostring");
-  for (i=1; i<=n; i++) {
-    const char *s;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
-    lua_call(L, 1, 1);
-    s = lua_tostring(L, -1);  /* get result */
-    if (s == NULL)
-      return luaL_error(L, LUA_QL("tostring") " must return a string to "
-                           LUA_QL("print"));
-    if (i>1) fputs("\t", stdout);
-    fputs(s, stdout);
-    lua_pop(L, 1);  /* pop result */
-  }
-  fputs("\n", stdout);
-  return 0;
-}
-
-
-static int luaB_tonumber (lua_State *L) {
-  int base = luaL_optint(L, 2, 10);
-  if (base == 10) {  /* standard conversion */
-    luaL_checkany(L, 1);
-    if (lua_isnumber(L, 1)) {
-      lua_pushnumber(L, lua_tonumber(L, 1));
-      return 1;
-    }
-  }
-  else {
-    const char *s1 = luaL_checkstring(L, 1);
-    char *s2;
-    unsigned long n;
-    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    n = strtoul(s1, &s2, base);
-    if (s1 != s2) {  /* at least one valid digit? */
-      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
-      if (*s2 == '\0') {  /* no invalid trailing characters? */
-        lua_pushnumber(L, (lua_Number)n);
-        return 1;
-      }
-    }
-  }
-  lua_pushnil(L);  /* else not a number */
-  return 1;
-}
-
-
-static int luaB_error (lua_State *L) {
-  int level = luaL_optint(L, 2, 1);
-  lua_settop(L, 1);
-  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
-    luaL_where(L, level);
-    lua_pushvalue(L, 1);
-    lua_concat(L, 2);
-  }
-  return lua_error(L);
-}
-
-
-static int luaB_getmetatable (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_getmetatable(L, 1)) {
-    lua_pushnil(L);
-    return 1;  /* no metatable */
-  }
-  luaL_getmetafield(L, 1, "__metatable");
-  return 1;  /* returns either __metatable field (if present) or metatable */
-}
-
-
-static int luaB_setmetatable (lua_State *L) {
-  int t = lua_type(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
-  if (luaL_getmetafield(L, 1, "__metatable"))
-    luaL_error(L, "cannot change a protected metatable");
-  lua_settop(L, 2);
-  lua_setmetatable(L, 1);
-  return 1;
-}
-
-
-static void getfunc (lua_State *L, int opt) {
-  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
-  else {
-    lua_Debug ar;
-    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
-    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
-    if (lua_getstack(L, level, &ar) == 0)
-      luaL_argerror(L, 1, "invalid level");
-    lua_getinfo(L, "f", &ar);
-    if (lua_isnil(L, -1))
-      luaL_error(L, "no function environment for tail call at level %d",
-                    level);
-  }
-}
-
-
-static int luaB_getfenv (lua_State *L) {
-  getfunc(L, 1);
-  if (lua_iscfunction(L, -1))  /* is a C function? */
-    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
-  else
-    lua_getfenv(L, -1);
-  return 1;
-}
-
-
-static int luaB_setfenv (lua_State *L) {
-  luaL_checktype(L, 2, LUA_TTABLE);
-  getfunc(L, 0);
-  lua_pushvalue(L, 2);
-  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
-    /* change environment of current thread */
-    lua_pushthread(L);
-    lua_insert(L, -2);
-    lua_setfenv(L, -2);
-    return 0;
-  }
-  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
-    luaL_error(L,
-          LUA_QL("setfenv") " cannot change environment of given object");
-  return 1;
-}
-
-
-static int luaB_rawequal (lua_State *L) {
-  luaL_checkany(L, 1);
-  luaL_checkany(L, 2);
-  lua_pushboolean(L, lua_rawequal(L, 1, 2));
-  return 1;
-}
-
-
-static int luaB_rawget (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  lua_rawget(L, 1);
-  return 1;
-}
-
-static int luaB_rawset (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checkany(L, 2);
-  luaL_checkany(L, 3);
-  lua_settop(L, 3);
-  lua_rawset(L, 1);
-  return 1;
-}
-
-
-static int luaB_gcinfo (lua_State *L) {
-  lua_pushinteger(L, lua_getgccount(L));
-  return 1;
-}
-
-
-static int luaB_collectgarbage (lua_State *L) {
-  static const char *const opts[] = {"stop", "restart", "collect",
-    "count", "step", "setpause", "setstepmul", NULL};
-  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
-    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
-  int o = luaL_checkoption(L, 1, "collect", opts);
-  int ex = luaL_optint(L, 2, 0);
-  int res = lua_gc(L, optsnum[o], ex);
-  switch (optsnum[o]) {
-    case LUA_GCCOUNT: {
-      int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, res + ((lua_Number)b/1024));
-      return 1;
-    }
-    case LUA_GCSTEP: {
-      lua_pushboolean(L, res);
-      return 1;
-    }
-    default: {
-      lua_pushnumber(L, res);
-      return 1;
-    }
-  }
-}
-
-
-static int luaB_type (lua_State *L) {
-  luaL_checkany(L, 1);
-  lua_pushstring(L, luaL_typename(L, 1));
-  return 1;
-}
-
-
-static int luaB_next (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
-  if (lua_next(L, 1))
-    return 2;
-  else {
-    lua_pushnil(L);
-    return 1;
-  }
-}
-
-
-static int luaB_pairs (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
-  lua_pushvalue(L, 1);  /* state, */
-  lua_pushnil(L);  /* and initial value */
-  return 3;
-}
-
-
-static int ipairsaux (lua_State *L) {
-  int i = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i++;  /* next value */
-  lua_pushinteger(L, i);
-  lua_rawgeti(L, 1, i);
-  return (lua_isnil(L, -1)) ? 0 : 2;
-}
-
-
-static int luaB_ipairs (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
-  lua_pushvalue(L, 1);  /* state, */
-  lua_pushinteger(L, 0);  /* and initial value */
-  return 3;
-}
-
-
-static int load_aux (lua_State *L, int status) {
-  if (status == 0)  /* OK? */
-    return 1;
-  else {
-    lua_pushnil(L);
-    lua_insert(L, -2);  /* put before error message */
-    return 2;  /* return nil plus error message */
-  }
-}
-
-
-static int luaB_loadstring (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  const char *chunkname = luaL_optstring(L, 2, s);
-  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
-}
-
-
-static int luaB_loadfile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  return load_aux(L, luaL_loadfile(L, fname));
-}
-
-
-/*
-** Reader for generic `load' function: `lua_load' uses the
-** stack for internal stuff, so the reader cannot change the
-** stack top. Instead, it keeps its resulting string in a
-** reserved slot inside the stack.
-*/
-static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
-  (void)ud;  /* to avoid warnings */
-  luaL_checkstack(L, 2, "too many nested functions");
-  lua_pushvalue(L, 1);  /* get function */
-  lua_call(L, 0, 1);  /* call it */
-  if (lua_isnil(L, -1)) {
-    *size = 0;
-    return NULL;
-  }
-  else if (lua_isstring(L, -1)) {
-    lua_replace(L, 3);  /* save string in a reserved stack slot */
-    return lua_tolstring(L, 3, size);
-  }
-  else luaL_error(L, "reader function must return a string");
-  return NULL;  /* to avoid warnings */
-}
-
-
-static int luaB_load (lua_State *L) {
-  int status;
-  const char *cname = luaL_optstring(L, 2, "=(load)");
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
-  status = lua_load(L, generic_reader, NULL, cname);
-  return load_aux(L, status);
-}
-
-
-static int luaB_dofile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  int n = lua_gettop(L);
-  if (luaL_loadfile(L, fname) != 0) lua_error(L);
-  lua_call(L, 0, LUA_MULTRET);
-  return lua_gettop(L) - n;
-}
-
-
-static int luaB_assert (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_toboolean(L, 1))
-    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
-  return lua_gettop(L);
-}
-
-
-static int luaB_unpack (lua_State *L) {
-  int i, e, n;
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i = luaL_optint(L, 2, 1);
-  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
-  if (i > e) return 0;  /* empty range */
-  n = e - i + 1;  /* number of elements */
-  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
-    return luaL_error(L, "too many results to unpack");
-  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
-  while (i++ < e)  /* push arg[i + 1...e] */
-    lua_rawgeti(L, 1, i);
-  return n;
-}
-
-
-static int luaB_select (lua_State *L) {
-  int n = lua_gettop(L);
-  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
-    lua_pushinteger(L, n-1);
-    return 1;
-  }
-  else {
-    int i = luaL_checkint(L, 1);
-    if (i < 0) i = n + i;
-    else if (i > n) i = n;
-    luaL_argcheck(L, 1 <= i, 1, "index out of range");
-    return n - i;
-  }
-}
-
-
-static int luaB_pcall (lua_State *L) {
-  int status;
-  luaL_checkany(L, 1);
-  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
-  lua_pushboolean(L, (status == 0));
-  lua_insert(L, 1);
-  return lua_gettop(L);  /* return status + all results */
-}
-
-
-static int luaB_xpcall (lua_State *L) {
-  int status;
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  lua_insert(L, 1);  /* put error function under function to be called */
-  status = lua_pcall(L, 0, LUA_MULTRET, 1);
-  lua_pushboolean(L, (status == 0));
-  lua_replace(L, 1);
-  return lua_gettop(L);  /* return status + all results */
-}
-
-
-static int luaB_tostring (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
-    return 1;  /* use its value */
-  switch (lua_type(L, 1)) {
-    case LUA_TNUMBER:
-      lua_pushstring(L, lua_tostring(L, 1));
-      break;
-    case LUA_TSTRING:
-      lua_pushvalue(L, 1);
-      break;
-    case LUA_TBOOLEAN:
-      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
-      break;
-    case LUA_TNIL:
-      lua_pushliteral(L, "nil");
-      break;
-    default:
-      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
-      break;
-  }
-  return 1;
-}
-
-
-static int luaB_newproxy (lua_State *L) {
-  lua_settop(L, 1);
-  lua_newuserdata(L, 0);  /* create proxy */
-  if (lua_toboolean(L, 1) == 0)
-    return 1;  /* no metatable */
-  else if (lua_isboolean(L, 1)) {
-    lua_newtable(L);  /* create a new metatable `m' ... */
-    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
-    lua_pushboolean(L, 1);
-    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
-  }
-  else {
-    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
-    if (lua_getmetatable(L, 1)) {
-      lua_rawget(L, lua_upvalueindex(1));
-      validproxy = lua_toboolean(L, -1);
-      lua_pop(L, 1);  /* remove value */
-    }
-    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
-    lua_getmetatable(L, 1);  /* metatable is valid; get it */
-  }
-  lua_setmetatable(L, 2);
-  return 1;
-}
-
-
-static const luaL_Reg base_funcs[] = {
-  {"assert", luaB_assert},
-  {"collectgarbage", luaB_collectgarbage},
-  {"dofile", luaB_dofile},
-  {"error", luaB_error},
-  {"gcinfo", luaB_gcinfo},
-  {"getfenv", luaB_getfenv},
-  {"getmetatable", luaB_getmetatable},
-  {"loadfile", luaB_loadfile},
-  {"load", luaB_load},
-  {"loadstring", luaB_loadstring},
-  {"next", luaB_next},
-  {"pcall", luaB_pcall},
-  {"print", luaB_print},
-  {"rawequal", luaB_rawequal},
-  {"rawget", luaB_rawget},
-  {"rawset", luaB_rawset},
-  {"select", luaB_select},
-  {"setfenv", luaB_setfenv},
-  {"setmetatable", luaB_setmetatable},
-  {"tonumber", luaB_tonumber},
-  {"tostring", luaB_tostring},
-  {"type", luaB_type},
-  {"unpack", luaB_unpack},
-  {"xpcall", luaB_xpcall},
-  {NULL, NULL}
-};
-
-
-/*
-** {======================================================
-** Coroutine library
-** =======================================================
-*/
-
-#define CO_RUN 0       /* running */
-#define CO_SUS 1       /* suspended */
-#define CO_NOR 2       /* 'normal' (it resumed another coroutine) */
-#define CO_DEAD        3
-
-static const char *const statnames[] =
-    {"running", "suspended", "normal", "dead"};
-
-static int costatus (lua_State *L, lua_State *co) {
-  if (L == co) return CO_RUN;
-  switch (lua_status(co)) {
-    case LUA_YIELD:
-      return CO_SUS;
-    case 0: {
-      lua_Debug ar;
-      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
-        return CO_NOR;  /* it is running */
-      else if (lua_gettop(co) == 0)
-          return CO_DEAD;
-      else
-        return CO_SUS;  /* initial state */
-    }
-    default:  /* some error occured */
-      return CO_DEAD;
-  }
-}
-
-
-static int luaB_costatus (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  luaL_argcheck(L, co, 1, "coroutine expected");
-  lua_pushstring(L, statnames[costatus(L, co)]);
-  return 1;
-}
-
-
-static int auxresume (lua_State *L, lua_State *co, int narg) {
-  int status = costatus(L, co);
-  if (!lua_checkstack(co, narg))
-    luaL_error(L, "too many arguments to resume");
-  if (status != CO_SUS) {
-    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
-    return -1;  /* error flag */
-  }
-  lua_xmove(L, co, narg);
-  lua_setlevel(L, co);
-  status = lua_resume(co, narg);
-  if (status == 0 || status == LUA_YIELD) {
-    int nres = lua_gettop(co);
-    if (!lua_checkstack(L, nres + 1))
-      luaL_error(L, "too many results to resume");
-    lua_xmove(co, L, nres);  /* move yielded values */
-    return nres;
-  }
-  else {
-    lua_xmove(co, L, 1);  /* move error message */
-    return -1;  /* error flag */
-  }
-}
-
-
-static int luaB_coresume (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  int r;
-  luaL_argcheck(L, co, 1, "coroutine expected");
-  r = auxresume(L, co, lua_gettop(L) - 1);
-  if (r < 0) {
-    lua_pushboolean(L, 0);
-    lua_insert(L, -2);
-    return 2;  /* return false + error message */
-  }
-  else {
-    lua_pushboolean(L, 1);
-    lua_insert(L, -(r + 1));
-    return r + 1;  /* return true + `resume' returns */
-  }
-}
-
-
-static int luaB_auxwrap (lua_State *L) {
-  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
-  int r = auxresume(L, co, lua_gettop(L));
-  if (r < 0) {
-    if (lua_isstring(L, -1)) {  /* error object is a string? */
-      luaL_where(L, 1);  /* add extra info */
-      lua_insert(L, -2);
-      lua_concat(L, 2);
-    }
-    lua_error(L);  /* propagate error */
-  }
-  return r;
-}
-
-
-static int luaB_cocreate (lua_State *L) {
-  lua_State *NL = lua_newthread(L);
-  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
-    "Lua function expected");
-  lua_pushvalue(L, 1);  /* move function to top */
-  lua_xmove(L, NL, 1);  /* move function from L to NL */
-  return 1;
-}
-
-
-static int luaB_cowrap (lua_State *L) {
-  luaB_cocreate(L);
-  lua_pushcclosure(L, luaB_auxwrap, 1);
-  return 1;
-}
-
-
-static int luaB_yield (lua_State *L) {
-  return lua_yield(L, lua_gettop(L));
-}
-
-
-static int luaB_corunning (lua_State *L) {
-  if (lua_pushthread(L))
-    lua_pushnil(L);  /* main thread is not a coroutine */
-  return 1;
-}
-
-
-static const luaL_Reg co_funcs[] = {
-  {"create", luaB_cocreate},
-  {"resume", luaB_coresume},
-  {"running", luaB_corunning},
-  {"status", luaB_costatus},
-  {"wrap", luaB_cowrap},
-  {"yield", luaB_yield},
-  {NULL, NULL}
-};
-
-/* }====================================================== */
-
-
-static void auxopen (lua_State *L, const char *name,
-                     lua_CFunction f, lua_CFunction u) {
-  lua_pushcfunction(L, u);
-  lua_pushcclosure(L, f, 1);
-  lua_setfield(L, -2, name);
-}
-
-
-static void base_open (lua_State *L) {
-  /* set global _G */
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  lua_setglobal(L, "_G");
-  /* open lib into global table */
-  luaL_register(L, "_G", base_funcs);
-  lua_pushliteral(L, LUA_VERSION);
-  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
-  /* `ipairs' and `pairs' need auxliliary functions as upvalues */
-  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
-  auxopen(L, "pairs", luaB_pairs, luaB_next);
-  /* `newproxy' needs a weaktable as upvalue */
-  lua_createtable(L, 0, 1);  /* new table `w' */
-  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
-  lua_setmetatable(L, -2);
-  lua_pushliteral(L, "kv");
-  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
-  lua_pushcclosure(L, luaB_newproxy, 1);
-  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
-}
-
-
-LUALIB_API int luaopen_base (lua_State *L) {
-  base_open(L);
-  luaL_register(L, LUA_COLIBNAME, co_funcs);
-  return 2;
-}

diff --git a/source3/lua-5.1.4/src/lcode.c b/source3/lua-5.1.4/src/lcode.c
deleted file mode 100644 (file)
index 882b35c..0000000
--- a/source3/lua-5.1.4/src/lcode.c
+++ /dev/null
@@ -1,838 +0,0 @@
-/*
-** $Id: lcode.c,v 2.25.1.3 2007/12/28 15:32:23 roberto Exp $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdlib.h>
-
-#define lcode_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "ltable.h"
-
-
-#define hasjumps(e)    ((e)->t != (e)->f)
-
-
-static int isnumeral(expdesc *e) {
-  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
-}
-
-
-void luaK_nil (FuncState *fs, int from, int n) {
-  Instruction *previous;
-  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
-    if (fs->pc == 0) {  /* function start? */
-      if (from >= fs->nactvar)
-        return;  /* positions are already clean */
-    }
-    else {
-      previous = &fs->f->code[fs->pc-1];
-      if (GET_OPCODE(*previous) == OP_LOADNIL) {
-        int pfrom = GETARG_A(*previous);
-        int pto = GETARG_B(*previous);
-        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
-          if (from+n-1 > pto)
-            SETARG_B(*previous, from+n-1);
-          return;
-        }
-      }
-    }
-  }
-  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
-}
-
-
-int luaK_jump (FuncState *fs) {
-  int jpc = fs->jpc;  /* save list of jumps to here */
-  int j;
-  fs->jpc = NO_JUMP;
-  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
-  luaK_concat(fs, &j, jpc);  /* keep them on hold */
-  return j;
-}
-
-
-void luaK_ret (FuncState *fs, int first, int nret) {
-  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
-}
-
-
-static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
-  luaK_codeABC(fs, op, A, B, C);
-  return luaK_jump(fs);
-}
-
-
-static void fixjump (FuncState *fs, int pc, int dest) {
-  Instruction *jmp = &fs->f->code[pc];
-  int offset = dest-(pc+1);
-  lua_assert(dest != NO_JUMP);
-  if (abs(offset) > MAXARG_sBx)
-    luaX_syntaxerror(fs->ls, "control structure too long");
-  SETARG_sBx(*jmp, offset);
-}
-
-
-/*
-** returns current `pc' and marks it as a jump target (to avoid wrong
-** optimizations with consecutive instructions not in the same basic block).
-*/
-int luaK_getlabel (FuncState *fs) {
-  fs->lasttarget = fs->pc;
-  return fs->pc;
-}
-
-
-static int getjump (FuncState *fs, int pc) {
-  int offset = GETARG_sBx(fs->f->code[pc]);
-  if (offset == NO_JUMP)  /* point to itself represents end of list */
-    return NO_JUMP;  /* end of list */
-  else
-    return (pc+1)+offset;  /* turn offset into absolute position */
-}
-
-
-static Instruction *getjumpcontrol (FuncState *fs, int pc) {
-  Instruction *pi = &fs->f->code[pc];
-  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
-    return pi-1;
-  else
-    return pi;
-}
-
-
-/*
-** check whether list has any jump that do not produce a value
-** (or produce an inverted value)
-*/
-static int need_value (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list)) {
-    Instruction i = *getjumpcontrol(fs, list);
-    if (GET_OPCODE(i) != OP_TESTSET) return 1;
-  }
-  return 0;  /* not found */
-}
-
-
-static int patchtestreg (FuncState *fs, int node, int reg) {
-  Instruction *i = getjumpcontrol(fs, node);
-  if (GET_OPCODE(*i) != OP_TESTSET)
-    return 0;  /* cannot patch other instructions */
-  if (reg != NO_REG && reg != GETARG_B(*i))
-    SETARG_A(*i, reg);
-  else  /* no register to put value or register already has the value */
-    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
-
-  return 1;
-}
-
-
-static void removevalues (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list))
-      patchtestreg(fs, list, NO_REG);
-}
-
-
-static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
-                          int dtarget) {
-  while (list != NO_JUMP) {
-    int next = getjump(fs, list);
-    if (patchtestreg(fs, list, reg))
-      fixjump(fs, list, vtarget);
-    else
-      fixjump(fs, list, dtarget);  /* jump to default target */
-    list = next;
-  }
-}
-
-
-static void dischargejpc (FuncState *fs) {
-  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
-  fs->jpc = NO_JUMP;
-}
-
-
-void luaK_patchlist (FuncState *fs, int list, int target) {
-  if (target == fs->pc)
-    luaK_patchtohere(fs, list);
-  else {
-    lua_assert(target < fs->pc);
-    patchlistaux(fs, list, target, NO_REG, target);
-  }
-}
-
-
-void luaK_patchtohere (FuncState *fs, int list) {
-  luaK_getlabel(fs);
-  luaK_concat(fs, &fs->jpc, list);
-}
-
-
-void luaK_concat (FuncState *fs, int *l1, int l2) {
-  if (l2 == NO_JUMP) return;
-  else if (*l1 == NO_JUMP)
-    *l1 = l2;
-  else {
-    int list = *l1;
-    int next;
-    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
-      list = next;
-    fixjump(fs, list, l2);
-  }
-}
-
-
-void luaK_checkstack (FuncState *fs, int n) {
-  int newstack = fs->freereg + n;
-  if (newstack > fs->f->maxstacksize) {
-    if (newstack >= MAXSTACK)
-      luaX_syntaxerror(fs->ls, "function or expression too complex");
-    fs->f->maxstacksize = cast_byte(newstack);
-  }
-}
-
-
-void luaK_reserveregs (FuncState *fs, int n) {
-  luaK_checkstack(fs, n);
-  fs->freereg += n;
-}
-
-
-static void freereg (FuncState *fs, int reg) {
-  if (!ISK(reg) && reg >= fs->nactvar) {
-    fs->freereg--;
-    lua_assert(reg == fs->freereg);
-  }
-}
-
-
-static void freeexp (FuncState *fs, expdesc *e) {
-  if (e->k == VNONRELOC)
-    freereg(fs, e->u.s.info);
-}
-
-
-static int addk (FuncState *fs, TValue *k, TValue *v) {
-  lua_State *L = fs->L;
-  TValue *idx = luaH_set(L, fs->h, k);
-  Proto *f = fs->f;
-  int oldsize = f->sizek;
-  if (ttisnumber(idx)) {
-    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
-    return cast_int(nvalue(idx));
-  }
-  else {  /* constant not found; create a new entry */
-    setnvalue(idx, cast_num(fs->nk));
-    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
-                    MAXARG_Bx, "constant table overflow");
-    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
-    setobj(L, &f->k[fs->nk], v);
-    luaC_barrier(L, f, v);
-    return fs->nk++;
-  }
-}
-
-
-int luaK_stringK (FuncState *fs, TString *s) {
-  TValue o;
-  setsvalue(fs->L, &o, s);
-  return addk(fs, &o, &o);
-}
-
-
-int luaK_numberK (FuncState *fs, lua_Number r) {
-  TValue o;
-  setnvalue(&o, r);
-  return addk(fs, &o, &o);
-}
-
-
-static int boolK (FuncState *fs, int b) {
-  TValue o;
-  setbvalue(&o, b);
-  return addk(fs, &o, &o);
-}
-
-
-static int nilK (FuncState *fs) {
-  TValue k, v;
-  setnilvalue(&v);
-  /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->L, &k, fs->h);
-  return addk(fs, &k, &v);
-}
-
-
-void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    SETARG_C(getcode(fs, e), nresults+1);
-  }
-  else if (e->k == VVARARG) {
-    SETARG_B(getcode(fs, e), nresults+1);
-    SETARG_A(getcode(fs, e), fs->freereg);
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-
-void luaK_setoneret (FuncState *fs, expdesc *e) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    e->k = VNONRELOC;
-    e->u.s.info = GETARG_A(getcode(fs, e));
-  }
-  else if (e->k == VVARARG) {
-    SETARG_B(getcode(fs, e), 2);
-    e->k = VRELOCABLE;  /* can relocate its simple result */
-  }
-}
-
-
-void luaK_dischargevars (FuncState *fs, expdesc *e) {
-  switch (e->k) {
-    case VLOCAL: {
-      e->k = VNONRELOC;
-      break;
-    }
-    case VUPVAL: {
-      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VGLOBAL: {
-      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VINDEXED: {
-      freereg(fs, e->u.s.aux);
-      freereg(fs, e->u.s.info);
-      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VVARARG:
-    case VCALL: {
-      luaK_setoneret(fs, e);
-      break;
-    }
-    default: break;  /* there is one value available (somewhere) */
-  }
-}
-
-
-static int code_label (FuncState *fs, int A, int b, int jump) {
-  luaK_getlabel(fs);  /* those instructions may be jump targets */
-  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
-}
-
-
-static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: {
-      luaK_nil(fs, reg, 1);
-      break;
-    }
-    case VFALSE:  case VTRUE: {
-      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
-      break;
-    }
-    case VK: {
-      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
-      break;
-    }
-    case VKNUM: {
-      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
-      break;
-    }
-    case VRELOCABLE: {
-      Instruction *pc = &getcode(fs, e);
-      SETARG_A(*pc, reg);
-      break;
-    }
-    case VNONRELOC: {
-      if (reg != e->u.s.info)
-        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
-      break;
-    }
-    default: {
-      lua_assert(e->k == VVOID || e->k == VJMP);
-      return;  /* nothing to do... */
-    }
-  }
-  e->u.s.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-static void discharge2anyreg (FuncState *fs, expdesc *e) {
-  if (e->k != VNONRELOC) {
-    luaK_reserveregs(fs, 1);
-    discharge2reg(fs, e, fs->freereg-1);
-  }
-}
-
-
-static void exp2reg (FuncState *fs, expdesc *e, int reg) {
-  discharge2reg(fs, e, reg);
-  if (e->k == VJMP)
-    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
-  if (hasjumps(e)) {
-    int final;  /* position after whole expression */
-    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
-    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
-    if (need_value(fs, e->t) || need_value(fs, e->f)) {
-      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
-      p_f = code_label(fs, reg, 0, 1);
-      p_t = code_label(fs, reg, 1, 0);
-      luaK_patchtohere(fs, fj);
-    }
-    final = luaK_getlabel(fs);
-    patchlistaux(fs, e->f, final, reg, p_f);
-    patchlistaux(fs, e->t, final, reg, p_t);
-  }
-  e->f = e->t = NO_JUMP;
-  e->u.s.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  freeexp(fs, e);
-  luaK_reserveregs(fs, 1);
-  exp2reg(fs, e, fs->freereg - 1);
-}
-
-
-int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  if (e->k == VNONRELOC) {
-    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
-    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
-      exp2reg(fs, e, e->u.s.info);  /* put value on it */
-      return e->u.s.info;
-    }
-  }
-  luaK_exp2nextreg(fs, e);  /* default */
-  return e->u.s.info;
-}
-
-
-void luaK_exp2val (FuncState *fs, expdesc *e) {
-  if (hasjumps(e))
-    luaK_exp2anyreg(fs, e);
-  else
-    luaK_dischargevars(fs, e);
-}
-
-
-int luaK_exp2RK (FuncState *fs, expdesc *e) {
-  luaK_exp2val(fs, e);
-  switch (e->k) {
-    case VKNUM:
-    case VTRUE:
-    case VFALSE:
-    case VNIL: {
-      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
-        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
-                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
-                                        boolK(fs, (e->k == VTRUE));
-        e->k = VK;
-        return RKASK(e->u.s.info);
-      }
-      else break;
-    }
-    case VK: {
-      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
-        return RKASK(e->u.s.info);
-      else break;
-    }
-    default: break;
-  }
-  /* not a constant in the right range: put it in a register */
-  return luaK_exp2anyreg(fs, e);
-}
-
-
-void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
-  switch (var->k) {
-    case VLOCAL: {
-      freeexp(fs, ex);
-      exp2reg(fs, ex, var->u.s.info);
-      return;
-    }
-    case VUPVAL: {
-      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
-      break;
-    }
-    case VGLOBAL: {
-      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
-      break;
-    }
-    case VINDEXED: {
-      int e = luaK_exp2RK(fs, ex);
-      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
-      break;
-    }
-    default: {
-      lua_assert(0);  /* invalid var kind to store */
-      break;
-    }
-  }
-  freeexp(fs, ex);
-}
-
-
-void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
-  int func;
-  luaK_exp2anyreg(fs, e);
-  freeexp(fs, e);
-  func = fs->freereg;
-  luaK_reserveregs(fs, 2);
-  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
-  freeexp(fs, key);
-  e->u.s.info = func;
-  e->k = VNONRELOC;
-}
-
-
-static void invertjump (FuncState *fs, expdesc *e) {
-  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
-  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
-                                           GET_OPCODE(*pc) != OP_TEST);
-  SETARG_A(*pc, !(GETARG_A(*pc)));
-}
-
-
-static int jumponcond (FuncState *fs, expdesc *e, int cond) {
-  if (e->k == VRELOCABLE) {
-    Instruction ie = getcode(fs, e);
-    if (GET_OPCODE(ie) == OP_NOT) {
-      fs->pc--;  /* remove previous OP_NOT */
-      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
-    }
-    /* else go through */
-  }
-  discharge2anyreg(fs, e);
-  freeexp(fs, e);
-  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
-}
-
-
-void luaK_goiftrue (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of last jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VK: case VKNUM: case VTRUE: {
-      pc = NO_JUMP;  /* always true; do nothing */
-      break;
-    }
-    case VFALSE: {
-      pc = luaK_jump(fs);  /* always jump */
-      break;
-    }
-    case VJMP: {
-      invertjump(fs, e);
-      pc = e->u.s.info;
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 0);
-      break;
-    }
-  }
-  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
-  luaK_patchtohere(fs, e->t);
-  e->t = NO_JUMP;
-}
-
-
-static void luaK_goiffalse (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of last jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: case VFALSE: {
-      pc = NO_JUMP;  /* always false; do nothing */
-      break;
-    }
-    case VTRUE: {
-      pc = luaK_jump(fs);  /* always jump */
-      break;
-    }
-    case VJMP: {
-      pc = e->u.s.info;
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 1);
-      break;
-    }
-  }
-  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
-  luaK_patchtohere(fs, e->f);
-  e->f = NO_JUMP;
-}
-
-
-static void codenot (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: case VFALSE: {
-      e->k = VTRUE;
-      break;
-    }
-    case VK: case VKNUM: case VTRUE: {
-      e->k = VFALSE;
-      break;
-    }
-    case VJMP: {
-      invertjump(fs, e);
-      break;
-    }
-    case VRELOCABLE:
-    case VNONRELOC: {
-      discharge2anyreg(fs, e);
-      freeexp(fs, e);
-      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
-      e->k = VRELOCABLE;
-      break;
-    }
-    default: {
-      lua_assert(0);  /* cannot happen */
-      break;
-    }
-  }
-  /* interchange true and false lists */
-  { int temp = e->f; e->f = e->t; e->t = temp; }
-  removevalues(fs, e->f);
-  removevalues(fs, e->t);
-}
-
-
-void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
-  t->u.s.aux = luaK_exp2RK(fs, k);
-  t->k = VINDEXED;
-}
-
-
-static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
-  lua_Number v1, v2, r;
-  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
-  v1 = e1->u.nval;
-  v2 = e2->u.nval;
-  switch (op) {
-    case OP_ADD: r = luai_numadd(v1, v2); break;
-    case OP_SUB: r = luai_numsub(v1, v2); break;
-    case OP_MUL: r = luai_nummul(v1, v2); break;
-    case OP_DIV:
-      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
-      r = luai_numdiv(v1, v2); break;
-    case OP_MOD:
-      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
-      r = luai_nummod(v1, v2); break;
-    case OP_POW: r = luai_numpow(v1, v2); break;
-    case OP_UNM: r = luai_numunm(v1); break;
-    case OP_LEN: return 0;  /* no constant folding for 'len' */
-    default: lua_assert(0); r = 0; break;
-  }
-  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */
-  e1->u.nval = r;
-  return 1;
-}
-
-
-static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
-  if (constfolding(op, e1, e2))
-    return;
-  else {
-    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
-    int o1 = luaK_exp2RK(fs, e1);
-    if (o1 > o2) {
-      freeexp(fs, e1);
-      freeexp(fs, e2);
-    }
-    else {
-      freeexp(fs, e2);
-      freeexp(fs, e1);
-    }
-    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
-    e1->k = VRELOCABLE;
-  }
-}
-
-
-static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
-                                                          expdesc *e2) {
-  int o1 = luaK_exp2RK(fs, e1);
-  int o2 = luaK_exp2RK(fs, e2);
-  freeexp(fs, e2);
-  freeexp(fs, e1);
-  if (cond == 0 && op != OP_EQ) {
-    int temp;  /* exchange args to replace by `<' or `<=' */
-    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
-    cond = 1;
-  }
-  e1->u.s.info = condjump(fs, op, cond, o1, o2);
-  e1->k = VJMP;
-}
-
-
-void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
-  expdesc e2;
-  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
-  switch (op) {
-    case OPR_MINUS: {
-      if (!isnumeral(e))
-        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
-      codearith(fs, OP_UNM, e, &e2);
-      break;
-    }
-    case OPR_NOT: codenot(fs, e); break;
-    case OPR_LEN: {
-      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
-      codearith(fs, OP_LEN, e, &e2);
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
-  switch (op) {
-    case OPR_AND: {
-      luaK_goiftrue(fs, v);
-      break;
-    }
-    case OPR_OR: {
-      luaK_goiffalse(fs, v);
-      break;
-    }
-    case OPR_CONCAT: {
-      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
-      break;
-    }
-    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_MOD: case OPR_POW: {
-      if (!isnumeral(v)) luaK_exp2RK(fs, v);
-      break;
-    }
-    default: {
-      luaK_exp2RK(fs, v);
-      break;
-    }
-  }
-}
-
-
-void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
-  switch (op) {
-    case OPR_AND: {
-      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
-      luaK_dischargevars(fs, e2);
-      luaK_concat(fs, &e2->f, e1->f);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_OR: {
-      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
-      luaK_dischargevars(fs, e2);
-      luaK_concat(fs, &e2->t, e1->t);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_CONCAT: {
-      luaK_exp2val(fs, e2);
-      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
-        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
-        freeexp(fs, e1);
-        SETARG_B(getcode(fs, e2), e1->u.s.info);
-        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
-      }
-      else {
-        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
-        codearith(fs, OP_CONCAT, e1, e2);
-      }
-      break;
-    }
-    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
-    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
-    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
-    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
-    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
-    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
-    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
-    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
-    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
-    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
-    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
-    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
-    default: lua_assert(0);
-  }
-}
-
-
-void luaK_fixline (FuncState *fs, int line) {
-  fs->f->lineinfo[fs->pc - 1] = line;
-}
-
-
-static int luaK_code (FuncState *fs, Instruction i, int line) {
-  Proto *f = fs->f;
-  dischargejpc(fs);  /* `pc' will change */
-  /* put new instruction in code array */
-  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
-                  MAX_INT, "code size overflow");
-  f->code[fs->pc] = i;
-  /* save corresponding line information */
-  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
-                  MAX_INT, "code size overflow");
-  f->lineinfo[fs->pc] = line;
-  return fs->pc++;
-}
-
-
-int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
-  lua_assert(getOpMode(o) == iABC);
-  lua_assert(getBMode(o) != OpArgN || b == 0);
-  lua_assert(getCMode(o) != OpArgN || c == 0);
-  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
-}
-
-
-int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
-  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
-  lua_assert(getCMode(o) == OpArgN);
-  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
-}
-
-
-void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
-  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
-  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
-  lua_assert(tostore != 0);
-  if (c <= MAXARG_C)
-    luaK_codeABC(fs, OP_SETLIST, base, b, c);
-  else {
-    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
-    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
-  }
-  fs->freereg = base + 1;  /* free registers with list values */
-}

diff --git a/source3/lua-5.1.4/src/lcode.h b/source3/lua-5.1.4/src/lcode.h
deleted file mode 100644 (file)
index b941c60..0000000
--- a/source3/lua-5.1.4/src/lcode.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lcode_h
-#define lcode_h
-
-#include "llex.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-
-
-/*
-** Marks the end of a patch list. It is an invalid value both as an absolute
-** address, and as a list link (would link an element to itself).
-*/
-#define NO_JUMP (-1)
-
-
-/*
-** grep "ORDER OPR" if you change these enums
-*/
-typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
-  OPR_CONCAT,
-  OPR_NE, OPR_EQ,
-  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
-  OPR_AND, OPR_OR,
-  OPR_NOBINOPR
-} BinOpr;
-
-
-typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
-
-
-#define getcode(fs,e)  ((fs)->f->code[(e)->u.s.info])
-
-#define luaK_codeAsBx(fs,o,A,sBx)      luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
-
-#define luaK_setmultret(fs,e)  luaK_setreturns(fs, e, LUA_MULTRET)
-
-LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
-LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
-LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
-LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
-LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
-LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
-LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
-LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
-LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
-LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
-LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
-LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
-LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_jump (FuncState *fs);
-LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
-LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
-LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
-LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
-LUAI_FUNC int luaK_getlabel (FuncState *fs);
-LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
-LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
-LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
-LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/ldblib.c b/source3/lua-5.1.4/src/ldblib.c
deleted file mode 100644 (file)
index 1eb470b..0000000
--- a/source3/lua-5.1.4/src/ldblib.c
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
-** $Id: ldblib.c,v 1.104.1.3 2008/01/21 13:11:21 roberto Exp $
-** Interface from Lua to its debug API
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define ldblib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-static int db_getregistry (lua_State *L) {
-  lua_pushvalue(L, LUA_REGISTRYINDEX);
-  return 1;
-}
-
-
-static int db_getmetatable (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_getmetatable(L, 1)) {
-    lua_pushnil(L);  /* no metatable */
-  }
-  return 1;
-}
-
-
-static int db_setmetatable (lua_State *L) {
-  int t = lua_type(L, 2);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
-  lua_settop(L, 2);
-  lua_pushboolean(L, lua_setmetatable(L, 1));
-  return 1;
-}
-
-
-static int db_getfenv (lua_State *L) {
-  lua_getfenv(L, 1);
-  return 1;
-}
-
-
-static int db_setfenv (lua_State *L) {
-  luaL_checktype(L, 2, LUA_TTABLE);
-  lua_settop(L, 2);
-  if (lua_setfenv(L, 1) == 0)
-    luaL_error(L, LUA_QL("setfenv")
-                  " cannot change environment of given object");
-  return 1;
-}
-
-
-static void settabss (lua_State *L, const char *i, const char *v) {
-  lua_pushstring(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static void settabsi (lua_State *L, const char *i, int v) {
-  lua_pushinteger(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static lua_State *getthread (lua_State *L, int *arg) {
-  if (lua_isthread(L, 1)) {
-    *arg = 1;
-    return lua_tothread(L, 1);
-  }
-  else {
-    *arg = 0;
-    return L;
-  }
-}
-
-
-static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
-  if (L == L1) {
-    lua_pushvalue(L, -2);
-    lua_remove(L, -3);
-  }
-  else
-    lua_xmove(L1, L, 1);
-  lua_setfield(L, -2, fname);
-}
-
-
-static int db_getinfo (lua_State *L) {
-  lua_Debug ar;
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  const char *options = luaL_optstring(L, arg+2, "flnSu");
-  if (lua_isnumber(L, arg+1)) {
-    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
-      lua_pushnil(L);  /* level out of range */
-      return 1;
-    }
-  }
-  else if (lua_isfunction(L, arg+1)) {
-    lua_pushfstring(L, ">%s", options);
-    options = lua_tostring(L, -1);
-    lua_pushvalue(L, arg+1);
-    lua_xmove(L, L1, 1);
-  }
-  else
-    return luaL_argerror(L, arg+1, "function or level expected");
-  if (!lua_getinfo(L1, options, &ar))
-    return luaL_argerror(L, arg+2, "invalid option");
-  lua_createtable(L, 0, 2);
-  if (strchr(options, 'S')) {
-    settabss(L, "source", ar.source);
-    settabss(L, "short_src", ar.short_src);
-    settabsi(L, "linedefined", ar.linedefined);
-    settabsi(L, "lastlinedefined", ar.lastlinedefined);
-    settabss(L, "what", ar.what);
-  }
-  if (strchr(options, 'l'))
-    settabsi(L, "currentline", ar.currentline);
-  if (strchr(options, 'u'))
-    settabsi(L, "nups", ar.nups);
-  if (strchr(options, 'n')) {
-    settabss(L, "name", ar.name);
-    settabss(L, "namewhat", ar.namewhat);
-  }
-  if (strchr(options, 'L'))
-    treatstackoption(L, L1, "activelines");
-  if (strchr(options, 'f'))
-    treatstackoption(L, L1, "func");
-  return 1;  /* return table */
-}
-
-
-static int db_getlocal (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  const char *name;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
-    return luaL_argerror(L, arg+1, "level out of range");
-  name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
-  if (name) {
-    lua_xmove(L1, L, 1);
-    lua_pushstring(L, name);
-    lua_pushvalue(L, -2);
-    return 2;
-  }
-  else {
-    lua_pushnil(L);
-    return 1;
-  }
-}
-
-
-static int db_setlocal (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
-    return luaL_argerror(L, arg+1, "level out of range");
-  luaL_checkany(L, arg+3);
-  lua_settop(L, arg+3);
-  lua_xmove(L, L1, 1);
-  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
-  return 1;
-}
-
-
-static int auxupvalue (lua_State *L, int get) {
-  const char *name;
-  int n = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
-  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
-  if (name == NULL) return 0;
-  lua_pushstring(L, name);
-  lua_insert(L, -(get+1));
-  return get + 1;
-}
-
-
-static int db_getupvalue (lua_State *L) {
-  return auxupvalue(L, 1);
-}
-
-
-static int db_setupvalue (lua_State *L) {
-  luaL_checkany(L, 3);
-  return auxupvalue(L, 0);
-}
-
-
-
-static const char KEY_HOOK = 'h';
-
-
-static void hookf (lua_State *L, lua_Debug *ar) {
-  static const char *const hooknames[] =
-    {"call", "return", "line", "count", "tail return"};
-  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-  lua_rawget(L, LUA_REGISTRYINDEX);
-  lua_pushlightuserdata(L, L);
-  lua_rawget(L, -2);
-  if (lua_isfunction(L, -1)) {
-    lua_pushstring(L, hooknames[(int)ar->event]);
-    if (ar->currentline >= 0)
-      lua_pushinteger(L, ar->currentline);
-    else lua_pushnil(L);
-    lua_assert(lua_getinfo(L, "lS", ar));
-    lua_call(L, 2, 0);
-  }
-}
-
-
-static int makemask (const char *smask, int count) {
-  int mask = 0;
-  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
-  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
-  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
-  if (count > 0) mask |= LUA_MASKCOUNT;
-  return mask;
-}
-
-
-static char *unmakemask (int mask, char *smask) {
-  int i = 0;
-  if (mask & LUA_MASKCALL) smask[i++] = 'c';
-  if (mask & LUA_MASKRET) smask[i++] = 'r';
-  if (mask & LUA_MASKLINE) smask[i++] = 'l';
-  smask[i] = '\0';
-  return smask;
-}
-
-
-static void gethooktable (lua_State *L) {
-  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-  lua_rawget(L, LUA_REGISTRYINDEX);
-  if (!lua_istable(L, -1)) {
-    lua_pop(L, 1);
-    lua_createtable(L, 0, 1);
-    lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-    lua_pushvalue(L, -2);
-    lua_rawset(L, LUA_REGISTRYINDEX);
-  }
-}
-
-
-static int db_sethook (lua_State *L) {
-  int arg, mask, count;
-  lua_Hook func;
-  lua_State *L1 = getthread(L, &arg);
-  if (lua_isnoneornil(L, arg+1)) {
-    lua_settop(L, arg+1);
-    func = NULL; mask = 0; count = 0;  /* turn off hooks */
-  }
-  else {
-    const char *smask = luaL_checkstring(L, arg+2);
-    luaL_checktype(L, arg+1, LUA_TFUNCTION);
-    count = luaL_optint(L, arg+3, 0);
-    func = hookf; mask = makemask(smask, count);
-  }
-  gethooktable(L);
-  lua_pushlightuserdata(L, L1);
-  lua_pushvalue(L, arg+1);
-  lua_rawset(L, -3);  /* set new hook */
-  lua_pop(L, 1);  /* remove hook table */
-  lua_sethook(L1, func, mask, count);  /* set hooks */
-  return 0;
-}
-
-
-static int db_gethook (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  char buff[5];
-  int mask = lua_gethookmask(L1);
-  lua_Hook hook = lua_gethook(L1);
-  if (hook != NULL && hook != hookf)  /* external hook? */
-    lua_pushliteral(L, "external hook");
-  else {
-    gethooktable(L);
-    lua_pushlightuserdata(L, L1);
-    lua_rawget(L, -2);   /* get hook */
-    lua_remove(L, -2);  /* remove hook table */
-  }
-  lua_pushstring(L, unmakemask(mask, buff));
-  lua_pushinteger(L, lua_gethookcount(L1));
-  return 3;
-}
-
-
-static int db_debug (lua_State *L) {
-  for (;;) {
-    char buffer[250];
-    fputs("lua_debug> ", stderr);
-    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
-        strcmp(buffer, "cont\n") == 0)
-      return 0;
-    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
-        lua_pcall(L, 0, 0, 0)) {
-      fputs(lua_tostring(L, -1), stderr);
-      fputs("\n", stderr);
-    }
-    lua_settop(L, 0);  /* remove eventual returns */
-  }
-}
-
-
-#define LEVELS1        12      /* size of the first part of the stack */
-#define LEVELS2        10      /* size of the second part of the stack */
-
-static int db_errorfb (lua_State *L) {
-  int level;
-  int firstpart = 1;  /* still before eventual `...' */
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  if (lua_isnumber(L, arg+2)) {
-    level = (int)lua_tointeger(L, arg+2);
-    lua_pop(L, 1);
-  }
-  else
-    level = (L == L1) ? 1 : 0;  /* level 0 may be this own function */
-  if (lua_gettop(L) == arg)
-    lua_pushliteral(L, "");
-  else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */
-  else lua_pushliteral(L, "\n");
-  lua_pushliteral(L, "stack traceback:");
-  while (lua_getstack(L1, level++, &ar)) {
-    if (level > LEVELS1 && firstpart) {
-      /* no more than `LEVELS2' more levels? */
-      if (!lua_getstack(L1, level+LEVELS2, &ar))
-        level--;  /* keep going */
-      else {
-        lua_pushliteral(L, "\n\t...");  /* too many levels */
-        while (lua_getstack(L1, level+LEVELS2, &ar))  /* find last levels */
-          level++;
-      }
-      firstpart = 0;
-      continue;
-    }
-    lua_pushliteral(L, "\n\t");
-    lua_getinfo(L1, "Snl", &ar);
-    lua_pushfstring(L, "%s:", ar.short_src);
-    if (ar.currentline > 0)
-      lua_pushfstring(L, "%d:", ar.currentline);
-    if (*ar.namewhat != '\0')  /* is there a name? */
-        lua_pushfstring(L, " in function " LUA_QS, ar.name);
-    else {
-      if (*ar.what == 'm')  /* main? */
-        lua_pushfstring(L, " in main chunk");
-      else if (*ar.what == 'C' || *ar.what == 't')
-        lua_pushliteral(L, " ?");  /* C function or tail call */
-      else
-        lua_pushfstring(L, " in function <%s:%d>",
-                           ar.short_src, ar.linedefined);
-    }
-    lua_concat(L, lua_gettop(L) - arg);
-  }
-  lua_concat(L, lua_gettop(L) - arg);
-  return 1;
-}
-
-
-static const luaL_Reg dblib[] = {
-  {"debug", db_debug},
-  {"getfenv", db_getfenv},
-  {"gethook", db_gethook},
-  {"getinfo", db_getinfo},
-  {"getlocal", db_getlocal},
-  {"getregistry", db_getregistry},
-  {"getmetatable", db_getmetatable},
-  {"getupvalue", db_getupvalue},
-  {"setfenv", db_setfenv},
-  {"sethook", db_sethook},
-  {"setlocal", db_setlocal},
-  {"setmetatable", db_setmetatable},
-  {"setupvalue", db_setupvalue},
-  {"traceback", db_errorfb},
-  {NULL, NULL}
-};
-
-
-LUALIB_API int luaopen_debug (lua_State *L) {
-  luaL_register(L, LUA_DBLIBNAME, dblib);
-  return 1;
-}

diff --git a/source3/lua-5.1.4/src/ldebug.c b/source3/lua-5.1.4/src/ldebug.c
deleted file mode 100644 (file)
index 497d549..0000000
--- a/source3/lua-5.1.4/src/ldebug.c
+++ /dev/null
@@ -1,637 +0,0 @@
-/*
-** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $
-** Debug Interface
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <string.h>
-
-
-#define ldebug_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
-
-
-static int currentpc (lua_State *L, CallInfo *ci) {
-  if (!isLua(ci)) return -1;  /* function is not a Lua function? */
-  if (ci == L->ci)
-    ci->savedpc = L->savedpc;
-  return pcRel(ci->savedpc, ci_func(ci)->l.p);
-}
-
-
-static int currentline (lua_State *L, CallInfo *ci) {
-  int pc = currentpc(L, ci);
-  if (pc < 0)
-    return -1;  /* only active lua functions have current-line information */
-  else
-    return getline(ci_func(ci)->l.p, pc);
-}
-
-
-/*
-** this function can be called asynchronous (e.g. during a signal)
-*/
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
-  if (func == NULL || mask == 0) {  /* turn off hooks? */
-    mask = 0;
-    func = NULL;
-  }
-  L->hook = func;
-  L->basehookcount = count;
-  resethookcount(L);
-  L->hookmask = cast_byte(mask);
-  return 1;
-}
-
-
-LUA_API lua_Hook lua_gethook (lua_State *L) {
-  return L->hook;
-}
-
-
-LUA_API int lua_gethookmask (lua_State *L) {
-  return L->hookmask;
-}
-
-
-LUA_API int lua_gethookcount (lua_State *L) {
-  return L->basehookcount;
-}
-
-
-LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
-  int status;
-  CallInfo *ci;
-  lua_lock(L);
-  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
-    level--;
-    if (f_isLua(ci))  /* Lua function? */
-      level -= ci->tailcalls;  /* skip lost tail calls */
-  }
-  if (level == 0 && ci > L->base_ci) {  /* level found? */
-    status = 1;
-    ar->i_ci = cast_int(ci - L->base_ci);
-  }
-  else if (level < 0) {  /* level is of a lost tail call? */
-    status = 1;
-    ar->i_ci = 0;
-  }
-  else status = 0;  /* no such level */
-  lua_unlock(L);
-  return status;
-}
-
-
-static Proto *getluaproto (CallInfo *ci) {
-  return (isLua(ci) ? ci_func(ci)->l.p : NULL);
-}
-
-
-static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
-  const char *name;
-  Proto *fp = getluaproto(ci);
-  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
-    return name;  /* is a local variable in a Lua function */
-  else {
-    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
-    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
-      return "(*temporary)";
-    else
-      return NULL;
-  }
-}
-
-
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
-  CallInfo *ci = L->base_ci + ar->i_ci;
-  const char *name = findlocal(L, ci, n);
-  lua_lock(L);
-  if (name)
-      luaA_pushobject(L, ci->base + (n - 1));
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
-  CallInfo *ci = L->base_ci + ar->i_ci;
-  const char *name = findlocal(L, ci, n);
-  lua_lock(L);
-  if (name)
-      setobjs2s(L, ci->base + (n - 1), L->top - 1);
-  L->top--;  /* pop value */
-  lua_unlock(L);
-  return name;
-}
-
-
-static void funcinfo (lua_Debug *ar, Closure *cl) {
-  if (cl->c.isC) {
-    ar->source = "=[C]";
-    ar->linedefined = -1;
-    ar->lastlinedefined = -1;
-    ar->what = "C";
-  }
-  else {
-    ar->source = getstr(cl->l.p->source);
-    ar->linedefined = cl->l.p->linedefined;
-    ar->lastlinedefined = cl->l.p->lastlinedefined;
-    ar->what = (ar->linedefined == 0) ? "main" : "Lua";
-  }
-  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
-}
-
-
-static void info_tailcall (lua_Debug *ar) {
-  ar->name = ar->namewhat = "";
-  ar->what = "tail";
-  ar->lastlinedefined = ar->linedefined = ar->currentline = -1;
-  ar->source = "=(tail call)";
-  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
-  ar->nups = 0;
-}
-
-
-static void collectvalidlines (lua_State *L, Closure *f) {
-  if (f == NULL || f->c.isC) {
-    setnilvalue(L->top);
-  }
-  else {
-    Table *t = luaH_new(L, 0, 0);
-    int *lineinfo = f->l.p->lineinfo;
-    int i;
-    for (i=0; i<f->l.p->sizelineinfo; i++)
-      setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);
-    sethvalue(L, L->top, t);
-  }
-  incr_top(L);
-}
-
-
-static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
-                    Closure *f, CallInfo *ci) {
-  int status = 1;
-  if (f == NULL) {
-    info_tailcall(ar);
-    return status;
-  }
-  for (; *what; what++) {
-    switch (*what) {
-      case 'S': {
-        funcinfo(ar, f);
-        break;
-      }
-      case 'l': {
-        ar->currentline = (ci) ? currentline(L, ci) : -1;
-        break;
-      }
-      case 'u': {
-        ar->nups = f->c.nupvalues;
-        break;
-      }
-      case 'n': {
-        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
-        if (ar->namewhat == NULL) {
-          ar->namewhat = "";  /* not found */
-          ar->name = NULL;
-        }
-        break;
-      }
-      case 'L':
-      case 'f':  /* handled by lua_getinfo */
-        break;
-      default: status = 0;  /* invalid option */
-    }
-  }
-  return status;
-}
-
-
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
-  int status;
-  Closure *f = NULL;
-  CallInfo *ci = NULL;
-  lua_lock(L);
-  if (*what == '>') {
-    StkId func = L->top - 1;
-    luai_apicheck(L, ttisfunction(func));
-    what++;  /* skip the '>' */
-    f = clvalue(func);
-    L->top--;  /* pop function */
-  }
-  else if (ar->i_ci != 0) {  /* no tail call? */
-    ci = L->base_ci + ar->i_ci;
-    lua_assert(ttisfunction(ci->func));
-    f = clvalue(ci->func);
-  }
-  status = auxgetinfo(L, what, ar, f, ci);
-  if (strchr(what, 'f')) {
-    if (f == NULL) setnilvalue(L->top);
-    else setclvalue(L, L->top, f);
-    incr_top(L);
-  }
-  if (strchr(what, 'L'))
-    collectvalidlines(L, f);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** {======================================================
-** Symbolic Execution and code checker
-** =======================================================
-*/
-
-#define check(x)               if (!(x)) return 0;
-
-#define checkjump(pt,pc)       check(0 <= pc && pc < pt->sizecode)
-
-#define checkreg(pt,reg)       check((reg) < (pt)->maxstacksize)
-
-
-
-static int precheck (const Proto *pt) {
-  check(pt->maxstacksize <= MAXSTACK);
-  check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);
-  check(!(pt->is_vararg & VARARG_NEEDSARG) ||
-              (pt->is_vararg & VARARG_HASARG));
-  check(pt->sizeupvalues <= pt->nups);
-  check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);
-  check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
-  return 1;
-}
-
-
-#define checkopenop(pt,pc)     luaG_checkopenop((pt)->code[(pc)+1])
-
-int luaG_checkopenop (Instruction i) {
-  switch (GET_OPCODE(i)) {
-    case OP_CALL:
-    case OP_TAILCALL:
-    case OP_RETURN:
-    case OP_SETLIST: {
-      check(GETARG_B(i) == 0);
-      return 1;
-    }
-    default: return 0;  /* invalid instruction after an open call */
-  }
-}
-
-
-static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
-  switch (mode) {
-    case OpArgN: check(r == 0); break;
-    case OpArgU: break;
-    case OpArgR: checkreg(pt, r); break;
-    case OpArgK:
-      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
-      break;
-  }
-  return 1;
-}
-
-
-static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
-  int pc;
-  int last;  /* stores position of last instruction that changed `reg' */
-  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
-  check(precheck(pt));
-  for (pc = 0; pc < lastpc; pc++) {
-    Instruction i = pt->code[pc];
-    OpCode op = GET_OPCODE(i);
-    int a = GETARG_A(i);
-    int b = 0;
-    int c = 0;
-    check(op < NUM_OPCODES);
-    checkreg(pt, a);
-    switch (getOpMode(op)) {
-      case iABC: {
-        b = GETARG_B(i);
-        c = GETARG_C(i);
-        check(checkArgMode(pt, b, getBMode(op)));
-        check(checkArgMode(pt, c, getCMode(op)));
-        break;
-      }
-      case iABx: {
-        b = GETARG_Bx(i);
-        if (getBMode(op) == OpArgK) check(b < pt->sizek);
-        break;
-      }
-      case iAsBx: {
-        b = GETARG_sBx(i);
-        if (getBMode(op) == OpArgR) {
-          int dest = pc+1+b;
-          check(0 <= dest && dest < pt->sizecode);
-          if (dest > 0) {
-            int j;
-            /* check that it does not jump to a setlist count; this
-               is tricky, because the count from a previous setlist may
-               have the same value of an invalid setlist; so, we must
-               go all the way back to the first of them (if any) */
-            for (j = 0; j < dest; j++) {
-              Instruction d = pt->code[dest-1-j];
-              if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;
-            }
-            /* if 'j' is even, previous value is not a setlist (even if
-               it looks like one) */
-            check((j&1) == 0);
-          }
-        }
-        break;
-      }
-    }
-    if (testAMode(op)) {
-      if (a == reg) last = pc;  /* change register `a' */
-    }
-    if (testTMode(op)) {
-      check(pc+2 < pt->sizecode);  /* check skip */
-      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);
-    }
-    switch (op) {
-      case OP_LOADBOOL: {
-        if (c == 1) {  /* does it jump? */
-          check(pc+2 < pt->sizecode);  /* check its jump */
-          check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||
-                GETARG_C(pt->code[pc+1]) != 0);
-        }
-        break;
-      }
-      case OP_LOADNIL: {
-        if (a <= reg && reg <= b)
-          last = pc;  /* set registers from `a' to `b' */
-        break;
-      }
-      case OP_GETUPVAL:
-      case OP_SETUPVAL: {
-        check(b < pt->nups);
-        break;
-      }
-      case OP_GETGLOBAL:
-      case OP_SETGLOBAL: {
-        check(ttisstring(&pt->k[b]));
-        break;
-      }
-      case OP_SELF: {
-        checkreg(pt, a+1);
-        if (reg == a+1) last = pc;
-        break;
-      }
-      case OP_CONCAT: {
-        check(b < c);  /* at least two operands */
-        break;
-      }
-      case OP_TFORLOOP: {
-        check(c >= 1);  /* at least one result (control variable) */
-        checkreg(pt, a+2+c);  /* space for results */
-        if (reg >= a+2) last = pc;  /* affect all regs above its base */
-        break;
-      }
-      case OP_FORLOOP:
-      case OP_FORPREP:
-        checkreg(pt, a+3);
-        /* go through */
-      case OP_JMP: {
-        int dest = pc+1+b;
-        /* not full check and jump is forward and do not skip `lastpc'? */
-        if (reg != NO_REG && pc < dest && dest <= lastpc)
-          pc += b;  /* do the jump */
-        break;
-      }
-      case OP_CALL:
-      case OP_TAILCALL: {
-        if (b != 0) {
-          checkreg(pt, a+b-1);
-        }
-        c--;  /* c = num. returns */
-        if (c == LUA_MULTRET) {
-          check(checkopenop(pt, pc));
-        }
-        else if (c != 0)
-          checkreg(pt, a+c-1);
-        if (reg >= a) last = pc;  /* affect all registers above base */
-        break;
-      }
-      case OP_RETURN: {
-        b--;  /* b = num. returns */
-        if (b > 0) checkreg(pt, a+b-1);
-        break;
-      }
-      case OP_SETLIST: {
-        if (b > 0) checkreg(pt, a + b);
-        if (c == 0) {
-          pc++;
-          check(pc < pt->sizecode - 1);
-        }
-        break;
-      }
-      case OP_CLOSURE: {
-        int nup, j;
-        check(b < pt->sizep);
-        nup = pt->p[b]->nups;
-        check(pc + nup < pt->sizecode);
-        for (j = 1; j <= nup; j++) {
-          OpCode op1 = GET_OPCODE(pt->code[pc + j]);
-          check(op1 == OP_GETUPVAL || op1 == OP_MOVE);
-        }
-        if (reg != NO_REG)  /* tracing? */
-          pc += nup;  /* do not 'execute' these pseudo-instructions */
-        break;
-      }
-      case OP_VARARG: {
-        check((pt->is_vararg & VARARG_ISVARARG) &&
-             !(pt->is_vararg & VARARG_NEEDSARG));
-        b--;
-        if (b == LUA_MULTRET) check(checkopenop(pt, pc));
-        checkreg(pt, a+b-1);
-        break;
-      }
-      default: break;
-    }
-  }
-  return pt->code[last];
-}
-
-#undef check
-#undef checkjump
-#undef checkreg
-
-/* }====================================================== */
-
-
-int luaG_checkcode (const Proto *pt) {
-  return (symbexec(pt, pt->sizecode, NO_REG) != 0);
-}
-
-
-static const char *kname (Proto *p, int c) {
-  if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))
-    return svalue(&p->k[INDEXK(c)]);
-  else
-    return "?";
-}
-
-
-static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
-                               const char **name) {
-  if (isLua(ci)) {  /* a Lua function? */
-    Proto *p = ci_func(ci)->l.p;
-    int pc = currentpc(L, ci);
-    Instruction i;
-    *name = luaF_getlocalname(p, stackpos+1, pc);
-    if (*name)  /* is a local? */
-      return "local";
-    i = symbexec(p, pc, stackpos);  /* try symbolic execution */
-    lua_assert(pc != -1);
-    switch (GET_OPCODE(i)) {
-      case OP_GETGLOBAL: {
-        int g = GETARG_Bx(i);  /* global index */
-        lua_assert(ttisstring(&p->k[g]));
-        *name = svalue(&p->k[g]);
-        return "global";
-      }
-      case OP_MOVE: {
-        int a = GETARG_A(i);
-        int b = GETARG_B(i);  /* move from `b' to `a' */
-        if (b < a)
-          return getobjname(L, ci, b, name);  /* get name for `b' */
-        break;
-      }
-      case OP_GETTABLE: {
-        int k = GETARG_C(i);  /* key index */
-        *name = kname(p, k);
-        return "field";
-      }
-      case OP_GETUPVAL: {
-        int u = GETARG_B(i);  /* upvalue index */
-        *name = p->upvalues ? getstr(p->upvalues[u]) : "?";
-        return "upvalue";
-      }
-      case OP_SELF: {
-        int k = GETARG_C(i);  /* key index */
-        *name = kname(p, k);
-        return "method";
-      }
-      default: break;
-    }
-  }
-  return NULL;  /* no useful name found */
-}
-
-
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
-  Instruction i;
-  if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
-    return NULL;  /* calling function is not Lua (or is unknown) */
-  ci--;  /* calling function */
-  i = ci_func(ci)->l.p->code[currentpc(L, ci)];
-  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
-      GET_OPCODE(i) == OP_TFORLOOP)
-    return getobjname(L, ci, GETARG_A(i), name);
-  else
-    return NULL;  /* no useful name can be found */
-}
-
-
-/* only ANSI way to check whether a pointer points to an array */
-static int isinstack (CallInfo *ci, const TValue *o) {
-  StkId p;
-  for (p = ci->base; p < ci->top; p++)
-    if (o == p) return 1;
-  return 0;
-}
-
-
-void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
-  const char *name = NULL;
-  const char *t = luaT_typenames[ttype(o)];
-  const char *kind = (isinstack(L->ci, o)) ?
-                         getobjname(L, L->ci, cast_int(o - L->base), &name) :
-                         NULL;
-  if (kind)
-    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
-                op, kind, name, t);
-  else
-    luaG_runerror(L, "attempt to %s a %s value", op, t);
-}
-
-
-void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
-  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;
-  lua_assert(!ttisstring(p1) && !ttisnumber(p1));
-  luaG_typeerror(L, p1, "concatenate");
-}
-
-
-void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
-  TValue temp;
-  if (luaV_tonumber(p1, &temp) == NULL)
-    p2 = p1;  /* first operand is wrong */
-  luaG_typeerror(L, p2, "perform arithmetic on");
-}
-
-
-int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
-  const char *t1 = luaT_typenames[ttype(p1)];
-  const char *t2 = luaT_typenames[ttype(p2)];
-  if (t1[2] == t2[2])
-    luaG_runerror(L, "attempt to compare two %s values", t1);
-  else
-    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
-  return 0;
-}
-
-
-static void addinfo (lua_State *L, const char *msg) {
-  CallInfo *ci = L->ci;
-  if (isLua(ci)) {  /* is Lua code? */
-    char buff[LUA_IDSIZE];  /* add file:line information */
-    int line = currentline(L, ci);
-    luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);
-    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
-  }
-}
-
-
-void luaG_errormsg (lua_State *L) {
-  if (L->errfunc != 0) {  /* is there an error handling function? */
-    StkId errfunc = restorestack(L, L->errfunc);
-    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
-    setobjs2s(L, L->top, L->top - 1);  /* move argument */
-    setobjs2s(L, L->top - 1, errfunc);  /* push function */
-    incr_top(L);
-    luaD_call(L, L->top - 2, 1);  /* call it */
-  }
-  luaD_throw(L, LUA_ERRRUN);
-}
-
-
-void luaG_runerror (lua_State *L, const char *fmt, ...) {
-  va_list argp;
-  va_start(argp, fmt);
-  addinfo(L, luaO_pushvfstring(L, fmt, argp));
-  va_end(argp);
-  luaG_errormsg(L);
-}

diff --git a/source3/lua-5.1.4/src/ldebug.h b/source3/lua-5.1.4/src/ldebug.h
deleted file mode 100644 (file)
index ba28a97..0000000
--- a/source3/lua-5.1.4/src/ldebug.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions from Debug Interface module
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ldebug_h
-#define ldebug_h
-
-
-#include "lstate.h"
-
-
-#define pcRel(pc, p)   (cast(int, (pc) - (p)->code) - 1)
-
-#define getline(f,pc)  (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
-
-#define resethookcount(L)      (L->hookcount = L->basehookcount)
-
-
-LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
-                                             const char *opname);
-LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
-LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,
-                                              const TValue *p2);
-LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,
-                                             const TValue *p2);
-LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);
-LUAI_FUNC void luaG_errormsg (lua_State *L);
-LUAI_FUNC int luaG_checkcode (const Proto *pt);
-LUAI_FUNC int luaG_checkopenop (Instruction i);
-
-#endif

diff --git a/source3/lua-5.1.4/src/ldo.c b/source3/lua-5.1.4/src/ldo.c
deleted file mode 100644 (file)
index b7c40d5..0000000
--- a/source3/lua-5.1.4/src/ldo.c
+++ /dev/null
@@ -1,516 +0,0 @@
-/*
-** $Id: ldo.c,v 2.38.1.3 2008/01/18 22:31:22 roberto Exp $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#include <setjmp.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define ldo_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lundump.h"
-#include "lvm.h"
-#include "lzio.h"
-
-
-
-
-/*
-** {======================================================
-** Error-recovery functions
-** =======================================================
-*/
-
-
-/* chain list of long jump buffers */
-struct lua_longjmp {
-  struct lua_longjmp *previous;
-  luai_jmpbuf b;
-  volatile int status;  /* error code */
-};
-
-
-void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
-  switch (errcode) {
-    case LUA_ERRMEM: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
-      break;
-    }
-    case LUA_ERRERR: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
-      break;
-    }
-    case LUA_ERRSYNTAX:
-    case LUA_ERRRUN: {
-      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
-      break;
-    }
-  }
-  L->top = oldtop + 1;
-}
-
-
-static void restore_stack_limit (lua_State *L) {
-  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
-  if (L->size_ci > LUAI_MAXCALLS) {  /* there was an overflow? */
-    int inuse = cast_int(L->ci - L->base_ci);
-    if (inuse + 1 < LUAI_MAXCALLS)  /* can `undo' overflow? */
-      luaD_reallocCI(L, LUAI_MAXCALLS);
-  }
-}
-
-
-static void resetstack (lua_State *L, int status) {
-  L->ci = L->base_ci;
-  L->base = L->ci->base;
-  luaF_close(L, L->base);  /* close eventual pending closures */
-  luaD_seterrorobj(L, status, L->base);
-  L->nCcalls = L->baseCcalls;
-  L->allowhook = 1;
-  restore_stack_limit(L);
-  L->errfunc = 0;
-  L->errorJmp = NULL;
-}
-
-
-void luaD_throw (lua_State *L, int errcode) {
-  if (L->errorJmp) {
-    L->errorJmp->status = errcode;
-    LUAI_THROW(L, L->errorJmp);
-  }
-  else {
-    L->status = cast_byte(errcode);
-    if (G(L)->panic) {
-      resetstack(L, errcode);
-      lua_unlock(L);
-      G(L)->panic(L);
-    }
-    exit(EXIT_FAILURE);
-  }
-}
-
-
-int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
-  struct lua_longjmp lj;
-  lj.status = 0;
-  lj.previous = L->errorJmp;  /* chain new error handler */
-  L->errorJmp = &lj;
-  LUAI_TRY(L, &lj,
-    (*f)(L, ud);
-  );
-  L->errorJmp = lj.previous;  /* restore old error handler */
-  return lj.status;
-}
-
-/* }====================================================== */
-
-
-static void correctstack (lua_State *L, TValue *oldstack) {
-  CallInfo *ci;
-  GCObject *up;
-  L->top = (L->top - oldstack) + L->stack;
-  for (up = L->openupval; up != NULL; up = up->gch.next)
-    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
-  for (ci = L->base_ci; ci <= L->ci; ci++) {
-    ci->top = (ci->top - oldstack) + L->stack;
-    ci->base = (ci->base - oldstack) + L->stack;
-    ci->func = (ci->func - oldstack) + L->stack;
-  }
-  L->base = (L->base - oldstack) + L->stack;
-}
-
-
-void luaD_reallocstack (lua_State *L, int newsize) {
-  TValue *oldstack = L->stack;
-  int realsize = newsize + 1 + EXTRA_STACK;
-  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
-  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
-  L->stacksize = realsize;
-  L->stack_last = L->stack+newsize;
-  correctstack(L, oldstack);
-}
-
-
-void luaD_reallocCI (lua_State *L, int newsize) {
-  CallInfo *oldci = L->base_ci;
-  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
-  L->size_ci = newsize;
-  L->ci = (L->ci - oldci) + L->base_ci;
-  L->end_ci = L->base_ci + L->size_ci - 1;
-}
-
-
-void luaD_growstack (lua_State *L, int n) {
-  if (n <= L->stacksize)  /* double size is enough? */
-    luaD_reallocstack(L, 2*L->stacksize);
-  else
-    luaD_reallocstack(L, L->stacksize + n);
-}
-
-
-static CallInfo *growCI (lua_State *L) {
-  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
-    luaD_throw(L, LUA_ERRERR);
-  else {
-    luaD_reallocCI(L, 2*L->size_ci);
-    if (L->size_ci > LUAI_MAXCALLS)
-      luaG_runerror(L, "stack overflow");
-  }
-  return ++L->ci;
-}
-
-
-void luaD_callhook (lua_State *L, int event, int line) {
-  lua_Hook hook = L->hook;
-  if (hook && L->allowhook) {
-    ptrdiff_t top = savestack(L, L->top);
-    ptrdiff_t ci_top = savestack(L, L->ci->top);
-    lua_Debug ar;
-    ar.event = event;
-    ar.currentline = line;
-    if (event == LUA_HOOKTAILRET)
-      ar.i_ci = 0;  /* tail call; no debug information about it */
-    else
-      ar.i_ci = cast_int(L->ci - L->base_ci);
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    L->ci->top = L->top + LUA_MINSTACK;
-    lua_assert(L->ci->top <= L->stack_last);
-    L->allowhook = 0;  /* cannot call hooks inside a hook */
-    lua_unlock(L);
-    (*hook)(L, &ar);
-    lua_lock(L);
-    lua_assert(!L->allowhook);
-    L->allowhook = 1;
-    L->ci->top = restorestack(L, ci_top);
-    L->top = restorestack(L, top);
-  }
-}
-
-
-static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
-  int i;
-  int nfixargs = p->numparams;
-  Table *htab = NULL;
-  StkId base, fixed;
-  for (; actual < nfixargs; ++actual)
-    setnilvalue(L->top++);
-#if defined(LUA_COMPAT_VARARG)
-  if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
-    int nvar = actual - nfixargs;  /* number of extra arguments */
-    lua_assert(p->is_vararg & VARARG_HASARG);
-    luaC_checkGC(L);
-    htab = luaH_new(L, nvar, 1);  /* create `arg' table */
-    for (i=0; i<nvar; i++)  /* put extra arguments into `arg' table */
-      setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
-    /* store counter in field `n' */
-    setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
-  }
-#endif
-  /* move fixed parameters to final position */
-  fixed = L->top - actual;  /* first fixed argument */
-  base = L->top;  /* final position of first argument */
-  for (i=0; i<nfixargs; i++) {
-    setobjs2s(L, L->top++, fixed+i);
-    setnilvalue(fixed+i);
-  }
-  /* add `arg' parameter */
-  if (htab) {
-    sethvalue(L, L->top++, htab);
-    lua_assert(iswhite(obj2gco(htab)));
-  }
-  return base;
-}
-
-
-static StkId tryfuncTM (lua_State *L, StkId func) {
-  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
-  StkId p;
-  ptrdiff_t funcr = savestack(L, func);
-  if (!ttisfunction(tm))
-    luaG_typeerror(L, func, "call");
-  /* Open a hole inside the stack at `func' */
-  for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
-  incr_top(L);
-  func = restorestack(L, funcr);  /* previous call may change stack */
-  setobj2s(L, func, tm);  /* tag method is the new function to be called */
-  return func;
-}
-
-
-
-#define inc_ci(L) \
-  ((L->ci == L->end_ci) ? growCI(L) : \
-   (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
-
-
-int luaD_precall (lua_State *L, StkId func, int nresults) {
-  LClosure *cl;
-  ptrdiff_t funcr;
-  if (!ttisfunction(func)) /* `func' is not a function? */
-    func = tryfuncTM(L, func);  /* check the `function' tag method */
-  funcr = savestack(L, func);
-  cl = &clvalue(func)->l;
-  L->ci->savedpc = L->savedpc;
-  if (!cl->isC) {  /* Lua function? prepare its call */
-    CallInfo *ci;
-    StkId st, base;
-    Proto *p = cl->p;
-    luaD_checkstack(L, p->maxstacksize);
-    func = restorestack(L, funcr);
-    if (!p->is_vararg) {  /* no varargs? */
-      base = func + 1;
-      if (L->top > base + p->numparams)
-        L->top = base + p->numparams;
-    }
-    else {  /* vararg function */
-      int nargs = cast_int(L->top - func) - 1;
-      base = adjust_varargs(L, p, nargs);
-      func = restorestack(L, funcr);  /* previous call may change the stack */
-    }
-    ci = inc_ci(L);  /* now `enter' new function */
-    ci->func = func;
-    L->base = ci->base = base;
-    ci->top = L->base + p->maxstacksize;
-    lua_assert(ci->top <= L->stack_last);
-    L->savedpc = p->code;  /* starting point */
-    ci->tailcalls = 0;
-    ci->nresults = nresults;
-    for (st = L->top; st < ci->top; st++)
-      setnilvalue(st);
-    L->top = ci->top;
-    if (L->hookmask & LUA_MASKCALL) {
-      L->savedpc++;  /* hooks assume 'pc' is already incremented */
-      luaD_callhook(L, LUA_HOOKCALL, -1);
-      L->savedpc--;  /* correct 'pc' */
-    }
-    return PCRLUA;
-  }
-  else {  /* if is a C function, call it */
-    CallInfo *ci;
-    int n;
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    ci = inc_ci(L);  /* now `enter' new function */
-    ci->func = restorestack(L, funcr);
-    L->base = ci->base = ci->func + 1;
-    ci->top = L->top + LUA_MINSTACK;
-    lua_assert(ci->top <= L->stack_last);
-    ci->nresults = nresults;
-    if (L->hookmask & LUA_MASKCALL)
-      luaD_callhook(L, LUA_HOOKCALL, -1);
-    lua_unlock(L);
-    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
-    lua_lock(L);
-    if (n < 0)  /* yielding? */
-      return PCRYIELD;
-    else {
-      luaD_poscall(L, L->top - n);
-      return PCRC;
-    }
-  }
-}
-
-
-static StkId callrethooks (lua_State *L, StkId firstResult) {
-  ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */
-  luaD_callhook(L, LUA_HOOKRET, -1);
-  if (f_isLua(L->ci)) {  /* Lua function? */
-    while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
-      luaD_callhook(L, LUA_HOOKTAILRET, -1);
-  }
-  return restorestack(L, fr);
-}
-
-
-int luaD_poscall (lua_State *L, StkId firstResult) {
-  StkId res;
-  int wanted, i;
-  CallInfo *ci;
-  if (L->hookmask & LUA_MASKRET)
-    firstResult = callrethooks(L, firstResult);
-  ci = L->ci--;
-  res = ci->func;  /* res == final position of 1st result */
-  wanted = ci->nresults;
-  L->base = (ci - 1)->base;  /* restore base */
-  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */
-  /* move results to correct place */
-  for (i = wanted; i != 0 && firstResult < L->top; i--)
-    setobjs2s(L, res++, firstResult++);
-  while (i-- > 0)
-    setnilvalue(res++);
-  L->top = res;
-  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
-}
-
-
-/*
-** Call a function (C or Lua). The function to be called is at *func.
-** The arguments are on the stack, right after the function.
-** When returns, all the results are on the stack, starting at the original
-** function position.
-*/
-void luaD_call (lua_State *L, StkId func, int nResults) {
-  if (++L->nCcalls >= LUAI_MAXCCALLS) {
-    if (L->nCcalls == LUAI_MAXCCALLS)
-      luaG_runerror(L, "C stack overflow");
-    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
-      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
-  }
-  if (luaD_precall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
-    luaV_execute(L, 1);  /* call it */
-  L->nCcalls--;
-  luaC_checkGC(L);
-}
-
-
-static void resume (lua_State *L, void *ud) {
-  StkId firstArg = cast(StkId, ud);
-  CallInfo *ci = L->ci;
-  if (L->status == 0) {  /* start coroutine? */
-    lua_assert(ci == L->base_ci && firstArg > L->base);
-    if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
-      return;
-  }
-  else {  /* resuming from previous yield */
-    lua_assert(L->status == LUA_YIELD);
-    L->status = 0;
-    if (!f_isLua(ci)) {  /* `common' yield? */
-      /* finish interrupted execution of `OP_CALL' */
-      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
-                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
-      if (luaD_poscall(L, firstArg))  /* complete it... */
-        L->top = L->ci->top;  /* and correct top if not multiple results */
-    }
-    else  /* yielded inside a hook: just continue its execution */
-      L->base = L->ci->base;
-  }
-  luaV_execute(L, cast_int(L->ci - L->base_ci));
-}
-
-
-static int resume_error (lua_State *L, const char *msg) {
-  L->top = L->ci->base;
-  setsvalue2s(L, L->top, luaS_new(L, msg));
-  incr_top(L);
-  lua_unlock(L);
-  return LUA_ERRRUN;
-}
-
-
-LUA_API int lua_resume (lua_State *L, int nargs) {
-  int status;
-  lua_lock(L);
-  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
-      return resume_error(L, "cannot resume non-suspended coroutine");
-  if (L->nCcalls >= LUAI_MAXCCALLS)
-    return resume_error(L, "C stack overflow");
-  luai_userstateresume(L, nargs);
-  lua_assert(L->errfunc == 0);
-  L->baseCcalls = ++L->nCcalls;
-  status = luaD_rawrunprotected(L, resume, L->top - nargs);
-  if (status != 0) {  /* error? */
-    L->status = cast_byte(status);  /* mark thread as `dead' */
-    luaD_seterrorobj(L, status, L->top);
-    L->ci->top = L->top;
-  }
-  else {
-    lua_assert(L->nCcalls == L->baseCcalls);
-    status = L->status;
-  }
-  --L->nCcalls;
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_yield (lua_State *L, int nresults) {
-  luai_userstateyield(L, nresults);
-  lua_lock(L);
-  if (L->nCcalls > L->baseCcalls)
-    luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
-  L->base = L->top - nresults;  /* protect stack slots below */
-  L->status = LUA_YIELD;
-  lua_unlock(L);
-  return -1;
-}
-
-
-int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                ptrdiff_t old_top, ptrdiff_t ef) {
-  int status;
-  unsigned short oldnCcalls = L->nCcalls;
-  ptrdiff_t old_ci = saveci(L, L->ci);
-  lu_byte old_allowhooks = L->allowhook;
-  ptrdiff_t old_errfunc = L->errfunc;
-  L->errfunc = ef;
-  status = luaD_rawrunprotected(L, func, u);
-  if (status != 0) {  /* an error occurred? */
-    StkId oldtop = restorestack(L, old_top);
-    luaF_close(L, oldtop);  /* close eventual pending closures */
-    luaD_seterrorobj(L, status, oldtop);
-    L->nCcalls = oldnCcalls;
-    L->ci = restoreci(L, old_ci);
-    L->base = L->ci->base;
-    L->savedpc = L->ci->savedpc;
-    L->allowhook = old_allowhooks;
-    restore_stack_limit(L);
-  }
-  L->errfunc = old_errfunc;
-  return status;
-}
-
-
-
-/*
-** Execute a protected parser.
-*/
-struct SParser {  /* data to `f_parser' */
-  ZIO *z;
-  Mbuffer buff;  /* buffer to be used by the scanner */
-  const char *name;
-};
-
-static void f_parser (lua_State *L, void *ud) {
-  int i;
-  Proto *tf;
-  Closure *cl;
-  struct SParser *p = cast(struct SParser *, ud);
-  int c = luaZ_lookahead(p->z);
-  luaC_checkGC(L);
-  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
-                                                             &p->buff, p->name);
-  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
-  cl->l.p = tf;
-  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
-    cl->l.upvals[i] = luaF_newupval(L);
-  setclvalue(L, L->top, cl);
-  incr_top(L);
-}
-
-
-int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
-  struct SParser p;
-  int status;
-  p.z = z; p.name = name;
-  luaZ_initbuffer(L, &p.buff);
-  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
-  luaZ_freebuffer(L, &p.buff);
-  return status;
-}

diff --git a/source3/lua-5.1.4/src/ldo.h b/source3/lua-5.1.4/src/ldo.h
deleted file mode 100644 (file)
index ac9c9e7..0000000
--- a/source3/lua-5.1.4/src/ldo.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ldo_h
-#define ldo_h
-
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lzio.h"
-
-
-#define luaD_checkstack(L,n)   \
-  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
-    luaD_growstack(L, n); \
-  else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
-
-
-#define incr_top(L) {luaD_checkstack(L,1); L->top++;}
-
-#define savestack(L,p)         ((char *)(p) - (char *)L->stack)
-#define restorestack(L,n)      ((TValue *)((char *)L->stack + (n)))
-
-#define saveci(L,p)            ((char *)(p) - (char *)L->base_ci)
-#define restoreci(L,n)         ((CallInfo *)((char *)L->base_ci + (n)))
-
-
-/* results from luaD_precall */
-#define PCRLUA         0       /* initiated a call to a Lua function */
-#define PCRC           1       /* did a call to a C function */
-#define PCRYIELD       2       /* C funtion yielded */
-
-
-/* type of protected functions, to be ran by `runprotected' */
-typedef void (*Pfunc) (lua_State *L, void *ud);
-
-LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
-LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
-LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
-LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
-LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                                        ptrdiff_t oldtop, ptrdiff_t ef);
-LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
-LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
-LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
-LUAI_FUNC void luaD_growstack (lua_State *L, int n);
-
-LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
-LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
-
-LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
-
-#endif

diff --git a/source3/lua-5.1.4/src/ldump.c b/source3/lua-5.1.4/src/ldump.c
deleted file mode 100644 (file)
index c9d3d48..0000000
--- a/source3/lua-5.1.4/src/ldump.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
-** save precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#include <stddef.h>
-
-#define ldump_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lundump.h"
-
-typedef struct {
- lua_State* L;
- lua_Writer writer;
- void* data;
- int strip;
- int status;
-} DumpState;
-
-#define DumpMem(b,n,size,D)    DumpBlock(b,(n)*(size),D)
-#define DumpVar(x,D)           DumpMem(&x,1,sizeof(x),D)
-
-static void DumpBlock(const void* b, size_t size, DumpState* D)
-{
- if (D->status==0)
- {
-  lua_unlock(D->L);
-  D->status=(*D->writer)(D->L,b,size,D->data);
-  lua_lock(D->L);
- }
-}
-
-static void DumpChar(int y, DumpState* D)
-{
- char x=(char)y;
- DumpVar(x,D);
-}
-
-static void DumpInt(int x, DumpState* D)
-{
- DumpVar(x,D);
-}
-
-static void DumpNumber(lua_Number x, DumpState* D)
-{
- DumpVar(x,D);
-}
-
-static void DumpVector(const void* b, int n, size_t size, DumpState* D)
-{
- DumpInt(n,D);
- DumpMem(b,n,size,D);
-}
-
-static void DumpString(const TString* s, DumpState* D)
-{
- if (s==NULL || getstr(s)==NULL)
- {
-  size_t size=0;
-  DumpVar(size,D);
- }
- else
- {
-  size_t size=s->tsv.len+1;            /* include trailing '\0' */
-  DumpVar(size,D);
-  DumpBlock(getstr(s),size,D);
- }
-}
-
-#define DumpCode(f,D)   DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
-
-static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
-
-static void DumpConstants(const Proto* f, DumpState* D)
-{
- int i,n=f->sizek;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  const TValue* o=&f->k[i];
-  DumpChar(ttype(o),D);
-  switch (ttype(o))
-  {
-   case LUA_TNIL:
-       break;
-   case LUA_TBOOLEAN:
-       DumpChar(bvalue(o),D);
-       break;
-   case LUA_TNUMBER:
-       DumpNumber(nvalue(o),D);
-       break;
-   case LUA_TSTRING:
-       DumpString(rawtsvalue(o),D);
-       break;
-   default:
-       lua_assert(0);                  /* cannot happen */
-       break;
-  }
- }
- n=f->sizep;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
-}
-
-static void DumpDebug(const Proto* f, DumpState* D)
-{
- int i,n;
- n= (D->strip) ? 0 : f->sizelineinfo;
- DumpVector(f->lineinfo,n,sizeof(int),D);
- n= (D->strip) ? 0 : f->sizelocvars;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  DumpString(f->locvars[i].varname,D);
-  DumpInt(f->locvars[i].startpc,D);
-  DumpInt(f->locvars[i].endpc,D);
- }
- n= (D->strip) ? 0 : f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
-}
-
-static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
-{
- DumpString((f->source==p || D->strip) ? NULL : f->source,D);
- DumpInt(f->linedefined,D);
- DumpInt(f->lastlinedefined,D);
- DumpChar(f->nups,D);
- DumpChar(f->numparams,D);
- DumpChar(f->is_vararg,D);
- DumpChar(f->maxstacksize,D);
- DumpCode(f,D);
- DumpConstants(f,D);
- DumpDebug(f,D);
-}
-
-static void DumpHeader(DumpState* D)
-{
- char h[LUAC_HEADERSIZE];
- luaU_header(h);
- DumpBlock(h,LUAC_HEADERSIZE,D);
-}
-
-/*
-** dump Lua function as precompiled chunk
-*/
-int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
-{
- DumpState D;
- D.L=L;
- D.writer=w;
- D.data=data;
- D.strip=strip;
- D.status=0;
- DumpHeader(&D);
- DumpFunction(f,NULL,&D);
- return D.status;
-}

diff --git a/source3/lua-5.1.4/src/lfunc.c b/source3/lua-5.1.4/src/lfunc.c
deleted file mode 100644 (file)
index 22f670e..0000000
--- a/source3/lua-5.1.4/src/lfunc.c
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define lfunc_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
-  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
-  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
-  c->c.isC = 1;
-  c->c.env = e;
-  c->c.nupvalues = cast_byte(nelems);
-  return c;
-}
-
-
-Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
-  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
-  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
-  c->l.isC = 0;
-  c->l.env = e;
-  c->l.nupvalues = cast_byte(nelems);
-  while (nelems--) c->l.upvals[nelems] = NULL;
-  return c;
-}
-
-
-UpVal *luaF_newupval (lua_State *L) {
-  UpVal *uv = luaM_new(L, UpVal);
-  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
-  uv->v = &uv->u.value;
-  setnilvalue(uv->v);
-  return uv;
-}
-
-
-UpVal *luaF_findupval (lua_State *L, StkId level) {
-  global_State *g = G(L);
-  GCObject **pp = &L->openupval;
-  UpVal *p;
-  UpVal *uv;
-  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
-    lua_assert(p->v != &p->u.value);
-    if (p->v == level) {  /* found a corresponding upvalue? */
-      if (isdead(g, obj2gco(p)))  /* is it dead? */
-        changewhite(obj2gco(p));  /* ressurect it */
-      return p;
-    }
-    pp = &p->next;
-  }
-  uv = luaM_new(L, UpVal);  /* not found: create a new one */
-  uv->tt = LUA_TUPVAL;
-  uv->marked = luaC_white(g);
-  uv->v = level;  /* current value lives in the stack */
-  uv->next = *pp;  /* chain it in the proper position */
-  *pp = obj2gco(uv);
-  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
-  uv->u.l.next = g->uvhead.u.l.next;
-  uv->u.l.next->u.l.prev = uv;
-  g->uvhead.u.l.next = uv;
-  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-  return uv;
-}
-
-
-static void unlinkupval (UpVal *uv) {
-  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-  uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
-  uv->u.l.prev->u.l.next = uv->u.l.next;
-}
-
-
-void luaF_freeupval (lua_State *L, UpVal *uv) {
-  if (uv->v != &uv->u.value)  /* is it open? */
-    unlinkupval(uv);  /* remove from open list */
-  luaM_free(L, uv);  /* free upvalue */
-}
-
-
-void luaF_close (lua_State *L, StkId level) {
-  UpVal *uv;
-  global_State *g = G(L);
-  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
-    GCObject *o = obj2gco(uv);
-    lua_assert(!isblack(o) && uv->v != &uv->u.value);
-    L->openupval = uv->next;  /* remove from `open' list */
-    if (isdead(g, o))
-      luaF_freeupval(L, uv);  /* free upvalue */
-    else {
-      unlinkupval(uv);
-      setobj(L, &uv->u.value, uv->v);
-      uv->v = &uv->u.value;  /* now current value lives here */
-      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
-    }
-  }
-}
-
-
-Proto *luaF_newproto (lua_State *L) {
-  Proto *f = luaM_new(L, Proto);
-  luaC_link(L, obj2gco(f), LUA_TPROTO);
-  f->k = NULL;
-  f->sizek = 0;
-  f->p = NULL;
-  f->sizep = 0;
-  f->code = NULL;
-  f->sizecode = 0;
-  f->sizelineinfo = 0;
-  f->sizeupvalues = 0;
-  f->nups = 0;
-  f->upvalues = NULL;
-  f->numparams = 0;
-  f->is_vararg = 0;
-  f->maxstacksize = 0;
-  f->lineinfo = NULL;
-  f->sizelocvars = 0;
-  f->locvars = NULL;
-  f->linedefined = 0;
-  f->lastlinedefined = 0;
-  f->source = NULL;
-  return f;
-}
-
-
-void luaF_freeproto (lua_State *L, Proto *f) {
-  luaM_freearray(L, f->code, f->sizecode, Instruction);
-  luaM_freearray(L, f->p, f->sizep, Proto *);
-  luaM_freearray(L, f->k, f->sizek, TValue);
-  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
-  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
-  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
-  luaM_free(L, f);
-}
-
-
-void luaF_freeclosure (lua_State *L, Closure *c) {
-  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
-                          sizeLclosure(c->l.nupvalues);
-  luaM_freemem(L, c, size);
-}
-
-
-/*
-** Look for n-th local variable at line `line' in function `func'.
-** Returns NULL if not found.
-*/
-const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
-  int i;
-  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
-    if (pc < f->locvars[i].endpc) {  /* is variable active? */
-      local_number--;
-      if (local_number == 0)
-        return getstr(f->locvars[i].varname);
-    }
-  }
-  return NULL;  /* not found */
-}

diff --git a/source3/lua-5.1.4/src/lfunc.h b/source3/lua-5.1.4/src/lfunc.h
deleted file mode 100644 (file)
index a68cf51..0000000
--- a/source3/lua-5.1.4/src/lfunc.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lfunc_h
-#define lfunc_h
-
-
-#include "lobject.h"
-
-
-#define sizeCclosure(n)        (cast(int, sizeof(CClosure)) + \
-                         cast(int, sizeof(TValue)*((n)-1)))
-
-#define sizeLclosure(n)        (cast(int, sizeof(LClosure)) + \
-                         cast(int, sizeof(TValue *)*((n)-1)))
-
-
-LUAI_FUNC Proto *luaF_newproto (lua_State *L);
-LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
-LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
-LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
-LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
-LUAI_FUNC void luaF_close (lua_State *L, StkId level);
-LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
-LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
-LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
-LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
-                                         int pc);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/lgc.c b/source3/lua-5.1.4/src/lgc.c
deleted file mode 100644 (file)
index 1d1087e..0000000
--- a/source3/lua-5.1.4/src/lgc.c
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
-** $Id: lgc.c,v 2.38.1.1 2007/12/27 13:02:25 roberto Exp $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#include <string.h>
-
-#define lgc_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-#define GCSTEPSIZE     1024u
-#define GCSWEEPMAX     40
-#define GCSWEEPCOST    10
-#define GCFINALIZECOST 100
-
-
-#define maskmarks      cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
-
-#define makewhite(g,x) \
-   ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
-
-#define white2gray(x)  reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
-#define black2gray(x)  resetbit((x)->gch.marked, BLACKBIT)
-
-#define stringmark(s)  reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
-
-
-#define isfinalized(u)         testbit((u)->marked, FINALIZEDBIT)
-#define markfinalized(u)       l_setbit((u)->marked, FINALIZEDBIT)
-
-
-#define KEYWEAK         bitmask(KEYWEAKBIT)
-#define VALUEWEAK       bitmask(VALUEWEAKBIT)
-
-
-
-#define markvalue(g,o) { checkconsistency(o); \
-  if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
-
-#define markobject(g,t) { if (iswhite(obj2gco(t))) \
-               reallymarkobject(g, obj2gco(t)); }
-
-
-#define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)
-
-
-static void removeentry (Node *n) {
-  lua_assert(ttisnil(gval(n)));
-  if (iscollectable(gkey(n)))
-    setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
-}
-
-
-static void reallymarkobject (global_State *g, GCObject *o) {
-  lua_assert(iswhite(o) && !isdead(g, o));
-  white2gray(o);
-  switch (o->gch.tt) {
-    case LUA_TSTRING: {
-      return;
-    }
-    case LUA_TUSERDATA: {
-      Table *mt = gco2u(o)->metatable;
-      gray2black(o);  /* udata are never gray */
-      if (mt) markobject(g, mt);
-      markobject(g, gco2u(o)->env);
-      return;
-    }
-    case LUA_TUPVAL: {
-      UpVal *uv = gco2uv(o);
-      markvalue(g, uv->v);
-      if (uv->v == &uv->u.value)  /* closed? */
-        gray2black(o);  /* open upvalues are never black */
-      return;
-    }
-    case LUA_TFUNCTION: {
-      gco2cl(o)->c.gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    case LUA_TTABLE: {
-      gco2h(o)->gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    case LUA_TTHREAD: {
-      gco2th(o)->gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    case LUA_TPROTO: {
-      gco2p(o)->gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-static void marktmu (global_State *g) {
-  GCObject *u = g->tmudata;
-  if (u) {
-    do {
-      u = u->gch.next;
-      makewhite(g, u);  /* may be marked, if left from previous GC */
-      reallymarkobject(g, u);
-    } while (u != g->tmudata);
-  }
-}
-
-
-/* move `dead' udata that need finalization to list `tmudata' */
-size_t luaC_separateudata (lua_State *L, int all) {
-  global_State *g = G(L);
-  size_t deadmem = 0;
-  GCObject **p = &g->mainthread->next;
-  GCObject *curr;
-  while ((curr = *p) != NULL) {
-    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
-      p = &curr->gch.next;  /* don't bother with them */
-    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
-      markfinalized(gco2u(curr));  /* don't need finalization */
-      p = &curr->gch.next;
-    }
-    else {  /* must call its gc method */
-      deadmem += sizeudata(gco2u(curr));
-      markfinalized(gco2u(curr));
-      *p = curr->gch.next;
-      /* link `curr' at the end of `tmudata' list */
-      if (g->tmudata == NULL)  /* list is empty? */
-        g->tmudata = curr->gch.next = curr;  /* creates a circular list */
-      else {
-        curr->gch.next = g->tmudata->gch.next;
-        g->tmudata->gch.next = curr;
-        g->tmudata = curr;
-      }
-    }
-  }
-  return deadmem;
-}
-
-
-static int traversetable (global_State *g, Table *h) {
-  int i;
-  int weakkey = 0;
-  int weakvalue = 0;
-  const TValue *mode;
-  if (h->metatable)
-    markobject(g, h->metatable);
-  mode = gfasttm(g, h->metatable, TM_MODE);
-  if (mode && ttisstring(mode)) {  /* is there a weak mode? */
-    weakkey = (strchr(svalue(mode), 'k') != NULL);
-    weakvalue = (strchr(svalue(mode), 'v') != NULL);
-    if (weakkey || weakvalue) {  /* is really weak? */
-      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
-      h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
-                             (weakvalue << VALUEWEAKBIT));
-      h->gclist = g->weak;  /* must be cleared after GC, ... */
-      g->weak = obj2gco(h);  /* ... so put in the appropriate list */
-    }
-  }
-  if (weakkey && weakvalue) return 1;
-  if (!weakvalue) {
-    i = h->sizearray;
-    while (i--)
-      markvalue(g, &h->array[i]);
-  }
-  i = sizenode(h);
-  while (i--) {
-    Node *n = gnode(h, i);
-    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
-    if (ttisnil(gval(n)))
-      removeentry(n);  /* remove empty entries */
-    else {
-      lua_assert(!ttisnil(gkey(n)));
-      if (!weakkey) markvalue(g, gkey(n));
-      if (!weakvalue) markvalue(g, gval(n));
-    }
-  }
-  return weakkey || weakvalue;
-}
-
-
-/*
-** All marks are conditional because a GC may happen while the
-** prototype is still being created
-*/
-static void traverseproto (global_State *g, Proto *f) {
-  int i;
-  if (f->source) stringmark(f->source);
-  for (i=0; i<f->sizek; i++)  /* mark literals */
-    markvalue(g, &f->k[i]);
-  for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */
-    if (f->upvalues[i])
-      stringmark(f->upvalues[i]);
-  }
-  for (i=0; i<f->sizep; i++) {  /* mark nested protos */
-    if (f->p[i])
-      markobject(g, f->p[i]);
-  }
-  for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */
-    if (f->locvars[i].varname)
-      stringmark(f->locvars[i].varname);
-  }
-}
-
-
-
-static void traverseclosure (global_State *g, Closure *cl) {
-  markobject(g, cl->c.env);
-  if (cl->c.isC) {
-    int i;
-    for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
-      markvalue(g, &cl->c.upvalue[i]);
-  }
-  else {
-    int i;
-    lua_assert(cl->l.nupvalues == cl->l.p->nups);
-    markobject(g, cl->l.p);
-    for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */
-      markobject(g, cl->l.upvals[i]);
-  }
-}
-
-
-static void checkstacksizes (lua_State *L, StkId max) {
-  int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */
-  int s_used = cast_int(max - L->stack);  /* part of stack in use */
-  if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */
-    return;  /* do not touch the stacks */
-  if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
-    luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
-  condhardstacktests(luaD_reallocCI(L, ci_used + 1));
-  if (4*s_used < L->stacksize &&
-      2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
-    luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
-  condhardstacktests(luaD_reallocstack(L, s_used));
-}
-
-
-static void traversestack (global_State *g, lua_State *l) {
-  StkId o, lim;
-  CallInfo *ci;
-  markvalue(g, gt(l));
-  lim = l->top;
-  for (ci = l->base_ci; ci <= l->ci; ci++) {
-    lua_assert(ci->top <= l->stack_last);
-    if (lim < ci->top) lim = ci->top;
-  }
-  for (o = l->stack; o < l->top; o++)
-    markvalue(g, o);
-  for (; o <= lim; o++)
-    setnilvalue(o);
-  checkstacksizes(l, lim);
-}
-
-
-/*
-** traverse one gray object, turning it to black.
-** Returns `quantity' traversed.
-*/
-static l_mem propagatemark (global_State *g) {
-  GCObject *o = g->gray;
-  lua_assert(isgray(o));
-  gray2black(o);
-  switch (o->gch.tt) {
-    case LUA_TTABLE: {
-      Table *h = gco2h(o);
-      g->gray = h->gclist;
-      if (traversetable(g, h))  /* table is weak? */
-        black2gray(o);  /* keep it gray */
-      return sizeof(Table) + sizeof(TValue) * h->sizearray +
-                             sizeof(Node) * sizenode(h);
-    }
-    case LUA_TFUNCTION: {
-      Closure *cl = gco2cl(o);
-      g->gray = cl->c.gclist;
-      traverseclosure(g, cl);
-      return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
-                           sizeLclosure(cl->l.nupvalues);
-    }
-    case LUA_TTHREAD: {
-      lua_State *th = gco2th(o);
-      g->gray = th->gclist;
-      th->gclist = g->grayagain;
-      g->grayagain = o;
-      black2gray(o);
-      traversestack(g, th);
-      return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
-                                 sizeof(CallInfo) * th->size_ci;
-    }
-    case LUA_TPROTO: {
-      Proto *p = gco2p(o);
-      g->gray = p->gclist;
-      traverseproto(g, p);
-      return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
-                             sizeof(Proto *) * p->sizep +
-                             sizeof(TValue) * p->sizek +
-                             sizeof(int) * p->sizelineinfo +
-                             sizeof(LocVar) * p->sizelocvars +
-                             sizeof(TString *) * p->sizeupvalues;
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-static size_t propagateall (global_State *g) {
-  size_t m = 0;
-  while (g->gray) m += propagatemark(g);
-  return m;
-}
-
-
-/*
-** The next function tells whether a key or value can be cleared from
-** a weak table. Non-collectable objects are never removed from weak
-** tables. Strings behave as `values', so are never removed too. for
-** other objects: if really collected, cannot keep them; for userdata
-** being finalized, keep them in keys, but not in values
-*/
-static int iscleared (const TValue *o, int iskey) {
-  if (!iscollectable(o)) return 0;
-  if (ttisstring(o)) {
-    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
-    return 0;
-  }
-  return iswhite(gcvalue(o)) ||
-    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
-}
-
-
-/*
-** clear collected entries from weaktables
-*/
-static void cleartable (GCObject *l) {
-  while (l) {
-    Table *h = gco2h(l);
-    int i = h->sizearray;
-    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
-               testbit(h->marked, KEYWEAKBIT));
-    if (testbit(h->marked, VALUEWEAKBIT)) {
-      while (i--) {
-        TValue *o = &h->array[i];
-        if (iscleared(o, 0))  /* value was collected? */
-          setnilvalue(o);  /* remove value */
-      }
-    }
-    i = sizenode(h);
-    while (i--) {
-      Node *n = gnode(h, i);
-      if (!ttisnil(gval(n)) &&  /* non-empty entry? */
-          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
-        setnilvalue(gval(n));  /* remove value ... */
-        removeentry(n);  /* remove entry from table */
-      }
-    }
-    l = h->gclist;
-  }
-}
-
-
-static void freeobj (lua_State *L, GCObject *o) {
-  switch (o->gch.tt) {
-    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
-    case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
-    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
-    case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
-    case LUA_TTHREAD: {
-      lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
-      luaE_freethread(L, gco2th(o));
-      break;
-    }
-    case LUA_TSTRING: {
-      G(L)->strt.nuse--;
-      luaM_freemem(L, o, sizestring(gco2ts(o)));
-      break;
-    }
-    case LUA_TUSERDATA: {
-      luaM_freemem(L, o, sizeudata(gco2u(o)));
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-
-#define sweepwholelist(L,p)    sweeplist(L,p,MAX_LUMEM)
-
-
-static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
-  GCObject *curr;
-  global_State *g = G(L);
-  int deadmask = otherwhite(g);
-  while ((curr = *p) != NULL && count-- > 0) {
-    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
-      sweepwholelist(L, &gco2th(curr)->openupval);
-    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
-      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
-      makewhite(g, curr);  /* make it white (for next cycle) */
-      p = &curr->gch.next;
-    }
-    else {  /* must erase `curr' */
-      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
-      *p = curr->gch.next;
-      if (curr == g->rootgc)  /* is the first element of the list? */
-        g->rootgc = curr->gch.next;  /* adjust first */
-      freeobj(L, curr);
-    }
-  }
-  return p;
-}
-
-
-static void checkSizes (lua_State *L) {
-  global_State *g = G(L);
-  /* check size of string hash */
-  if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
-      g->strt.size > MINSTRTABSIZE*2)
-    luaS_resize(L, g->strt.size/2);  /* table is too big */
-  /* check size of buffer */
-  if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
-    size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
-    luaZ_resizebuffer(L, &g->buff, newsize);
-  }
-}
-
-
-static void GCTM (lua_State *L) {
-  global_State *g = G(L);
-  GCObject *o = g->tmudata->gch.next;  /* get first element */
-  Udata *udata = rawgco2u(o);
-  const TValue *tm;
-  /* remove udata from `tmudata' */
-  if (o == g->tmudata)  /* last element? */
-    g->tmudata = NULL;
-  else
-    g->tmudata->gch.next = udata->uv.next;
-  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
-  g->mainthread->next = o;
-  makewhite(g, o);
-  tm = fasttm(L, udata->uv.metatable, TM_GC);
-  if (tm != NULL) {
-    lu_byte oldah = L->allowhook;
-    lu_mem oldt = g->GCthreshold;
-    L->allowhook = 0;  /* stop debug hooks during GC tag method */
-    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
-    setobj2s(L, L->top, tm);
-    setuvalue(L, L->top+1, udata);
-    L->top += 2;
-    luaD_call(L, L->top - 2, 0);
-    L->allowhook = oldah;  /* restore hooks */
-    g->GCthreshold = oldt;  /* restore threshold */
-  }
-}
-
-
-/*
-** Call all GC tag methods
-*/
-void luaC_callGCTM (lua_State *L) {
-  while (G(L)->tmudata)
-    GCTM(L);
-}
-
-
-void luaC_freeall (lua_State *L) {
-  global_State *g = G(L);
-  int i;
-  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
-  sweepwholelist(L, &g->rootgc);
-  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
-    sweepwholelist(L, &g->strt.hash[i]);
-}
-
-
-static void markmt (global_State *g) {
-  int i;
-  for (i=0; i<NUM_TAGS; i++)
-    if (g->mt[i]) markobject(g, g->mt[i]);
-}
-
-
-/* mark root set */
-static void markroot (lua_State *L) {
-  global_State *g = G(L);
-  g->gray = NULL;
-  g->grayagain = NULL;
-  g->weak = NULL;
-  markobject(g, g->mainthread);
-  /* make global table be traversed before main stack */
-  markvalue(g, gt(g->mainthread));
-  markvalue(g, registry(L));
-  markmt(g);
-  g->gcstate = GCSpropagate;
-}
-
-
-static void remarkupvals (global_State *g) {
-  UpVal *uv;
-  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
-    lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-    if (isgray(obj2gco(uv)))
-      markvalue(g, uv->v);
-  }
-}
-
-
-static void atomic (lua_State *L) {
-  global_State *g = G(L);
-  size_t udsize;  /* total size of userdata to be finalized */
-  /* remark occasional upvalues of (maybe) dead threads */
-  remarkupvals(g);
-  /* traverse objects cautch by write barrier and by 'remarkupvals' */
-  propagateall(g);
-  /* remark weak tables */
-  g->gray = g->weak;
-  g->weak = NULL;
-  lua_assert(!iswhite(obj2gco(g->mainthread)));
-  markobject(g, L);  /* mark running thread */
-  markmt(g);  /* mark basic metatables (again) */
-  propagateall(g);
-  /* remark gray again */
-  g->gray = g->grayagain;
-  g->grayagain = NULL;
-  propagateall(g);
-  udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
-  marktmu(g);  /* mark `preserved' userdata */
-  udsize += propagateall(g);  /* remark, to propagate `preserveness' */
-  cleartable(g->weak);  /* remove collected objects from weak tables */
-  /* flip current white */
-  g->currentwhite = cast_byte(otherwhite(g));
-  g->sweepstrgc = 0;
-  g->sweepgc = &g->rootgc;
-  g->gcstate = GCSsweepstring;
-  g->estimate = g->totalbytes - udsize;  /* first estimate */
-}
-
-
-static l_mem singlestep (lua_State *L) {
-  global_State *g = G(L);
-  /*lua_checkmemory(L);*/
-  switch (g->gcstate) {
-    case GCSpause: {
-      markroot(L);  /* start a new collection */
-      return 0;
-    }
-    case GCSpropagate: {
-      if (g->gray)
-        return propagatemark(g);
-      else {  /* no more `gray' objects */
-        atomic(L);  /* finish mark phase */
-        return 0;
-      }
-    }
-    case GCSsweepstring: {
-      lu_mem old = g->totalbytes;
-      sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
-      if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
-        g->gcstate = GCSsweep;  /* end sweep-string phase */
-      lua_assert(old >= g->totalbytes);
-      g->estimate -= old - g->totalbytes;
-      return GCSWEEPCOST;
-    }
-    case GCSsweep: {
-      lu_mem old = g->totalbytes;
-      g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
-      if (*g->sweepgc == NULL) {  /* nothing more to sweep? */
-        checkSizes(L);
-        g->gcstate = GCSfinalize;  /* end sweep phase */
-      }
-      lua_assert(old >= g->totalbytes);
-      g->estimate -= old - g->totalbytes;
-      return GCSWEEPMAX*GCSWEEPCOST;
-    }
-    case GCSfinalize: {
-      if (g->tmudata) {
-        GCTM(L);
-        if (g->estimate > GCFINALIZECOST)
-          g->estimate -= GCFINALIZECOST;
-        return GCFINALIZECOST;
-      }
-      else {
-        g->gcstate = GCSpause;  /* end collection */
-        g->gcdept = 0;
-        return 0;
-      }
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-void luaC_step (lua_State *L) {
-  global_State *g = G(L);
-  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
-  if (lim == 0)
-    lim = (MAX_LUMEM-1)/2;  /* no limit */
-  g->gcdept += g->totalbytes - g->GCthreshold;
-  do {
-    lim -= singlestep(L);
-    if (g->gcstate == GCSpause)
-      break;
-  } while (lim > 0);
-  if (g->gcstate != GCSpause) {
-    if (g->gcdept < GCSTEPSIZE)
-      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
-    else {
-      g->gcdept -= GCSTEPSIZE;
-      g->GCthreshold = g->totalbytes;
-    }
-  }
-  else {
-    lua_assert(g->totalbytes >= g->estimate);
-    setthreshold(g);
-  }
-}
-
-
-void luaC_fullgc (lua_State *L) {
-  global_State *g = G(L);
-  if (g->gcstate <= GCSpropagate) {
-    /* reset sweep marks to sweep all elements (returning them to white) */
-    g->sweepstrgc = 0;
-    g->sweepgc = &g->rootgc;
-    /* reset other collector lists */
-    g->gray = NULL;
-    g->grayagain = NULL;
-    g->weak = NULL;
-    g->gcstate = GCSsweepstring;
-  }
-  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
-  /* finish any pending sweep phase */
-  while (g->gcstate != GCSfinalize) {
-    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
-    singlestep(L);
-  }
-  markroot(L);
-  while (g->gcstate != GCSpause) {
-    singlestep(L);
-  }
-  setthreshold(g);
-}
-
-
-void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
-  global_State *g = G(L);
-  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
-  lua_assert(ttype(&o->gch) != LUA_TTABLE);
-  /* must keep invariant? */
-  if (g->gcstate == GCSpropagate)
-    reallymarkobject(g, v);  /* restore invariant */
-  else  /* don't mind */
-    makewhite(g, o);  /* mark as white just to avoid other barriers */
-}
-
-
-void luaC_barrierback (lua_State *L, Table *t) {
-  global_State *g = G(L);
-  GCObject *o = obj2gco(t);
-  lua_assert(isblack(o) && !isdead(g, o));
-  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
-  black2gray(o);  /* make table gray (again) */
-  t->gclist = g->grayagain;
-  g->grayagain = o;
-}
-
-
-void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
-  global_State *g = G(L);
-  o->gch.next = g->rootgc;
-  g->rootgc = o;
-  o->gch.marked = luaC_white(g);
-  o->gch.tt = tt;
-}
-
-
-void luaC_linkupval (lua_State *L, UpVal *uv) {
-  global_State *g = G(L);
-  GCObject *o = obj2gco(uv);
-  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
-  g->rootgc = o;
-  if (isgray(o)) {
-    if (g->gcstate == GCSpropagate) {
-      gray2black(o);  /* closed upvalues need barrier */
-      luaC_barrier(L, uv, uv->v);
-    }
-    else {  /* sweep phase: sweep it (turning it into white) */
-      makewhite(g, o);
-      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
-    }
-  }
-}

diff --git a/source3/lua-5.1.4/src/lgc.h b/source3/lua-5.1.4/src/lgc.h
deleted file mode 100644 (file)
index 5a8dc60..0000000
--- a/source3/lua-5.1.4/src/lgc.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lgc_h
-#define lgc_h
-
-
-#include "lobject.h"
-
-
-/*
-** Possible states of the Garbage Collector
-*/
-#define GCSpause       0
-#define GCSpropagate   1
-#define GCSsweepstring 2
-#define GCSsweep       3
-#define GCSfinalize    4
-
-
-/*
-** some userful bit tricks
-*/
-#define resetbits(x,m) ((x) &= cast(lu_byte, ~(m)))
-#define setbits(x,m)   ((x) |= (m))
-#define testbits(x,m)  ((x) & (m))
-#define bitmask(b)     (1<<(b))
-#define bit2mask(b1,b2)        (bitmask(b1) | bitmask(b2))
-#define l_setbit(x,b)  setbits(x, bitmask(b))
-#define resetbit(x,b)  resetbits(x, bitmask(b))
-#define testbit(x,b)   testbits(x, bitmask(b))
-#define set2bits(x,b1,b2)      setbits(x, (bit2mask(b1, b2)))
-#define reset2bits(x,b1,b2)    resetbits(x, (bit2mask(b1, b2)))
-#define test2bits(x,b1,b2)     testbits(x, (bit2mask(b1, b2)))
-
-
-
-/*
-** Layout for bit use in `marked' field:
-** bit 0 - object is white (type 0)
-** bit 1 - object is white (type 1)
-** bit 2 - object is black
-** bit 3 - for userdata: has been finalized
-** bit 3 - for tables: has weak keys
-** bit 4 - for tables: has weak values
-** bit 5 - object is fixed (should not be collected)
-** bit 6 - object is "super" fixed (only the main thread)
-*/
-
-
-#define WHITE0BIT      0
-#define WHITE1BIT      1
-#define BLACKBIT       2
-#define FINALIZEDBIT   3
-#define KEYWEAKBIT     3
-#define VALUEWEAKBIT   4
-#define FIXEDBIT       5
-#define SFIXEDBIT      6
-#define WHITEBITS      bit2mask(WHITE0BIT, WHITE1BIT)
-
-
-#define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
-#define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
-#define isgray(x)      (!isblack(x) && !iswhite(x))
-
-#define otherwhite(g)  (g->currentwhite ^ WHITEBITS)
-#define isdead(g,v)    ((v)->gch.marked & otherwhite(g) & WHITEBITS)
-
-#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
-#define gray2black(x)  l_setbit((x)->gch.marked, BLACKBIT)
-
-#define valiswhite(x)  (iscollectable(x) && iswhite(gcvalue(x)))
-
-#define luaC_white(g)  cast(lu_byte, (g)->currentwhite & WHITEBITS)
-
-
-#define luaC_checkGC(L) { \
-  condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
-  if (G(L)->totalbytes >= G(L)->GCthreshold) \
-       luaC_step(L); }
-
-
-#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
-       luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
-
-#define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \
-       luaC_barrierback(L,t); }
-
-#define luaC_objbarrier(L,p,o)  \
-       { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
-               luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
-
-#define luaC_objbarriert(L,t,o)  \
-   { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
-
-LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
-LUAI_FUNC void luaC_callGCTM (lua_State *L);
-LUAI_FUNC void luaC_freeall (lua_State *L);
-LUAI_FUNC void luaC_step (lua_State *L);
-LUAI_FUNC void luaC_fullgc (lua_State *L);
-LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
-LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
-LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
-LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/linit.c b/source3/lua-5.1.4/src/linit.c
deleted file mode 100644 (file)
index 16c72ac..0000000
--- a/source3/lua-5.1.4/src/linit.c
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $
-** Initialization of libraries for lua.c
-** See Copyright Notice in lua.h
-*/
-
-
-#define linit_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lualib.h"
-#include "lauxlib.h"
-
-
-static const luaL_Reg lualibs[] = {
-  {"", luaopen_base},
-  {LUA_LOADLIBNAME, luaopen_package},
-  {LUA_TABLIBNAME, luaopen_table},
-  {LUA_IOLIBNAME, luaopen_io},
-  {LUA_OSLIBNAME, luaopen_os},
-  {LUA_STRLIBNAME, luaopen_string},
-  {LUA_MATHLIBNAME, luaopen_math},
-  {LUA_DBLIBNAME, luaopen_debug},
-  {NULL, NULL}
-};
-
-
-LUALIB_API void luaL_openlibs (lua_State *L) {
-  const luaL_Reg *lib = lualibs;
-  for (; lib->func; lib++) {
-    lua_pushcfunction(L, lib->func);
-    lua_pushstring(L, lib->name);
-    lua_call(L, 1, 0);
-  }
-}

diff --git a/source3/lua-5.1.4/src/liolib.c b/source3/lua-5.1.4/src/liolib.c
deleted file mode 100644 (file)
index 38b2c55..0000000
--- a/source3/lua-5.1.4/src/liolib.c
+++ /dev/null
@@ -1,552 +0,0 @@
-/*
-** $Id: liolib.c,v 2.73.1.3 2008/01/18 17:47:43 roberto Exp $
-** Standard I/O (and system) library
-** See Copyright Notice in lua.h
-*/
-
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define liolib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-#define IO_INPUT       1
-#define IO_OUTPUT      2
-
-
-static const char *const fnames[] = {"input", "output"};
-
-
-static int pushresult (lua_State *L, int i, const char *filename) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (i) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    if (filename)
-      lua_pushfstring(L, "%s: %s", filename, strerror(en));
-    else
-      lua_pushfstring(L, "%s", strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
-
-
-static void fileerror (lua_State *L, int arg, const char *filename) {
-  lua_pushfstring(L, "%s: %s", filename, strerror(errno));
-  luaL_argerror(L, arg, lua_tostring(L, -1));
-}
-
-
-#define tofilep(L)     ((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
-
-
-static int io_type (lua_State *L) {
-  void *ud;
-  luaL_checkany(L, 1);
-  ud = lua_touserdata(L, 1);
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
-  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
-    lua_pushnil(L);  /* not a file */
-  else if (*((FILE **)ud) == NULL)
-    lua_pushliteral(L, "closed file");
-  else
-    lua_pushliteral(L, "file");
-  return 1;
-}
-
-
-static FILE *tofile (lua_State *L) {
-  FILE **f = tofilep(L);
-  if (*f == NULL)
-    luaL_error(L, "attempt to use a closed file");
-  return *f;
-}
-
-
-
-/*
-** When creating file handles, always creates a `closed' file handle
-** before opening the actual file; so, if there is a memory error, the
-** file is not left opened.
-*/
-static FILE **newfile (lua_State *L) {
-  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
-  *pf = NULL;  /* file handle is currently `closed' */
-  luaL_getmetatable(L, LUA_FILEHANDLE);
-  lua_setmetatable(L, -2);
-  return pf;
-}
-
-
-/*
-** function to (not) close the standard files stdin, stdout, and stderr
-*/
-static int io_noclose (lua_State *L) {
-  lua_pushnil(L);
-  lua_pushliteral(L, "cannot close standard file");
-  return 2;
-}
-
-
-/*
-** function to close 'popen' files
-*/
-static int io_pclose (lua_State *L) {
-  FILE **p = tofilep(L);
-  int ok = lua_pclose(L, *p);
-  *p = NULL;
-  return pushresult(L, ok, NULL);
-}
-
-
-/*
-** function to close regular files
-*/
-static int io_fclose (lua_State *L) {
-  FILE **p = tofilep(L);
-  int ok = (fclose(*p) == 0);
-  *p = NULL;
-  return pushresult(L, ok, NULL);
-}
-
-
-static int aux_close (lua_State *L) {
-  lua_getfenv(L, 1);
-  lua_getfield(L, -1, "__close");
-  return (lua_tocfunction(L, -1))(L);
-}
-
-
-static int io_close (lua_State *L) {
-  if (lua_isnone(L, 1))
-    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
-  tofile(L);  /* make sure argument is a file */
-  return aux_close(L);
-}
-
-
-static int io_gc (lua_State *L) {
-  FILE *f = *tofilep(L);
-  /* ignore closed files */
-  if (f != NULL)
-    aux_close(L);
-  return 0;
-}
-
-
-static int io_tostring (lua_State *L) {
-  FILE *f = *tofilep(L);
-  if (f == NULL)
-    lua_pushliteral(L, "file (closed)");
-  else
-    lua_pushfstring(L, "file (%p)", f);
-  return 1;
-}
-
-
-static int io_open (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  FILE **pf = newfile(L);
-  *pf = fopen(filename, mode);
-  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
-}
-
-
-/*
-** this function has a separated environment, which defines the
-** correct __close for 'popen' files
-*/
-static int io_popen (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  FILE **pf = newfile(L);
-  *pf = lua_popen(L, filename, mode);
-  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
-}
-
-
-static int io_tmpfile (lua_State *L) {
-  FILE **pf = newfile(L);
-  *pf = tmpfile();
-  return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
-}
-
-
-static FILE *getiofile (lua_State *L, int findex) {
-  FILE *f;
-  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
-  f = *(FILE **)lua_touserdata(L, -1);
-  if (f == NULL)
-    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
-  return f;
-}
-
-
-static int g_iofile (lua_State *L, int f, const char *mode) {
-  if (!lua_isnoneornil(L, 1)) {
-    const char *filename = lua_tostring(L, 1);
-    if (filename) {
-      FILE **pf = newfile(L);
-      *pf = fopen(filename, mode);
-      if (*pf == NULL)
-        fileerror(L, 1, filename);
-    }
-    else {
-      tofile(L);  /* check that it's a valid file handle */
-      lua_pushvalue(L, 1);
-    }
-    lua_rawseti(L, LUA_ENVIRONINDEX, f);
-  }
-  /* return current value */
-  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
-  return 1;
-}
-
-
-static int io_input (lua_State *L) {
-  return g_iofile(L, IO_INPUT, "r");
-}
-
-
-static int io_output (lua_State *L) {
-  return g_iofile(L, IO_OUTPUT, "w");
-}
-
-
-static int io_readline (lua_State *L);
-
-
-static void aux_lines (lua_State *L, int idx, int toclose) {
-  lua_pushvalue(L, idx);
-  lua_pushboolean(L, toclose);  /* close/not close file when finished */
-  lua_pushcclosure(L, io_readline, 2);
-}
-
-
-static int f_lines (lua_State *L) {
-  tofile(L);  /* check that it's a valid file handle */
-  aux_lines(L, 1, 0);
-  return 1;
-}
-
-
-static int io_lines (lua_State *L) {
-  if (lua_isnoneornil(L, 1)) {  /* no arguments? */
-    /* will iterate over default input */
-    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
-    return f_lines(L);
-  }
-  else {
-    const char *filename = luaL_checkstring(L, 1);
-    FILE **pf = newfile(L);
-    *pf = fopen(filename, "r");
-    if (*pf == NULL)
-      fileerror(L, 1, filename);
-    aux_lines(L, lua_gettop(L), 1);
-    return 1;
-  }
-}
-
-
-/*
-** {======================================================
-** READ
-** =======================================================
-*/
-
-
-static int read_number (lua_State *L, FILE *f) {
-  lua_Number d;
-  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
-    lua_pushnumber(L, d);
-    return 1;
-  }
-  else return 0;  /* read fails */
-}
-
-
-static int test_eof (lua_State *L, FILE *f) {
-  int c = getc(f);
-  ungetc(c, f);
-  lua_pushlstring(L, NULL, 0);
-  return (c != EOF);
-}
-
-
-static int read_line (lua_State *L, FILE *f) {
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  for (;;) {
-    size_t l;
-    char *p = luaL_prepbuffer(&b);
-    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
-      luaL_pushresult(&b);  /* close buffer */
-      return (lua_objlen(L, -1) > 0);  /* check whether read something */
-    }
-    l = strlen(p);
-    if (l == 0 || p[l-1] != '\n')
-      luaL_addsize(&b, l);
-    else {
-      luaL_addsize(&b, l - 1);  /* do not include `eol' */
-      luaL_pushresult(&b);  /* close buffer */
-      return 1;  /* read at least an `eol' */
-    }
-  }
-}
-
-
-static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t rlen;  /* how much to read */
-  size_t nr;  /* number of chars actually read */
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
-  do {
-    char *p = luaL_prepbuffer(&b);
-    if (rlen > n) rlen = n;  /* cannot read more than asked */
-    nr = fread(p, sizeof(char), rlen, f);
-    luaL_addsize(&b, nr);
-    n -= nr;  /* still have to read `n' chars */
-  } while (n > 0 && nr == rlen);  /* until end of count or eof */
-  luaL_pushresult(&b);  /* close buffer */
-  return (n == 0 || lua_objlen(L, -1) > 0);
-}
-
-
-static int g_read (lua_State *L, FILE *f, int first) {
-  int nargs = lua_gettop(L) - 1;
-  int success;
-  int n;
-  clearerr(f);
-  if (nargs == 0) {  /* no arguments? */
-    success = read_line(L, f);
-    n = first+1;  /* to return 1 result */
-  }
-  else {  /* ensure stack space for all results and for auxlib's buffer */
-    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
-    success = 1;
-    for (n = first; nargs-- && success; n++) {
-      if (lua_type(L, n) == LUA_TNUMBER) {
-        size_t l = (size_t)lua_tointeger(L, n);
-        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
-      }
-      else {
-        const char *p = lua_tostring(L, n);
-        luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
-        switch (p[1]) {
-          case 'n':  /* number */
-            success = read_number(L, f);
-            break;
-          case 'l':  /* line */
-            success = read_line(L, f);
-            break;
-          case 'a':  /* file */
-            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
-            success = 1; /* always success */
-            break;
-          default:
-            return luaL_argerror(L, n, "invalid format");
-        }
-      }
-    }
-  }
-  if (ferror(f))
-    return pushresult(L, 0, NULL);
-  if (!success) {
-    lua_pop(L, 1);  /* remove last result */
-    lua_pushnil(L);  /* push nil instead */
-  }
-  return n - first;
-}
-
-
-static int io_read (lua_State *L) {
-  return g_read(L, getiofile(L, IO_INPUT), 1);
-}
-
-
-static int f_read (lua_State *L) {
-  return g_read(L, tofile(L), 2);
-}
-
-
-static int io_readline (lua_State *L) {
-  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
-  int sucess;
-  if (f == NULL)  /* file is already closed? */
-    luaL_error(L, "file is already closed");
-  sucess = read_line(L, f);
-  if (ferror(f))
-    return luaL_error(L, "%s", strerror(errno));
-  if (sucess) return 1;
-  else {  /* EOF */
-    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
-      lua_settop(L, 0);
-      lua_pushvalue(L, lua_upvalueindex(1));
-      aux_close(L);  /* close it */
-    }
-    return 0;
-  }
-}
-
-/* }====================================================== */
-
-
-static int g_write (lua_State *L, FILE *f, int arg) {
-  int nargs = lua_gettop(L) - 1;
-  int status = 1;
-  for (; nargs--; arg++) {
-    if (lua_type(L, arg) == LUA_TNUMBER) {
-      /* optimization: could be done exactly as for strings */
-      status = status &&
-          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
-    }
-    else {
-      size_t l;
-      const char *s = luaL_checklstring(L, arg, &l);
-      status = status && (fwrite(s, sizeof(char), l, f) == l);
-    }
-  }
-  return pushresult(L, status, NULL);
-}
-
-
-static int io_write (lua_State *L) {
-  return g_write(L, getiofile(L, IO_OUTPUT), 1);
-}
-
-
-static int f_write (lua_State *L) {
-  return g_write(L, tofile(L), 2);
-}
-
-
-static int f_seek (lua_State *L) {
-  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
-  static const char *const modenames[] = {"set", "cur", "end", NULL};
-  FILE *f = tofile(L);
-  int op = luaL_checkoption(L, 2, "cur", modenames);
-  long offset = luaL_optlong(L, 3, 0);
-  op = fseek(f, offset, mode[op]);
-  if (op)
-    return pushresult(L, 0, NULL);  /* error */
-  else {
-    lua_pushinteger(L, ftell(f));
-    return 1;
-  }
-}
-
-
-static int f_setvbuf (lua_State *L) {
-  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
-  static const char *const modenames[] = {"no", "full", "line", NULL};
-  FILE *f = tofile(L);
-  int op = luaL_checkoption(L, 2, NULL, modenames);
-  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
-  int res = setvbuf(f, NULL, mode[op], sz);
-  return pushresult(L, res == 0, NULL);
-}
-
-
-
-static int io_flush (lua_State *L) {
-  return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
-}
-
-
-static int f_flush (lua_State *L) {
-  return pushresult(L, fflush(tofile(L)) == 0, NULL);
-}
-
-
-static const luaL_Reg iolib[] = {
-  {"close", io_close},
-  {"flush", io_flush},
-  {"input", io_input},
-  {"lines", io_lines},
-  {"open", io_open},
-  {"output", io_output},
-  {"popen", io_popen},
-  {"read", io_read},
-  {"tmpfile", io_tmpfile},
-  {"type", io_type},
-  {"write", io_write},
-  {NULL, NULL}
-};
-
-
-static const luaL_Reg flib[] = {
-  {"close", io_close},
-  {"flush", f_flush},
-  {"lines", f_lines},
-  {"read", f_read},
-  {"seek", f_seek},
-  {"setvbuf", f_setvbuf},
-  {"write", f_write},
-  {"__gc", io_gc},
-  {"__tostring", io_tostring},
-  {NULL, NULL}
-};
-
-
-static void createmeta (lua_State *L) {
-  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
-  lua_pushvalue(L, -1);  /* push metatable */
-  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
-  luaL_register(L, NULL, flib);  /* file methods */
-}
-
-
-static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
-  *newfile(L) = f;
-  if (k > 0) {
-    lua_pushvalue(L, -1);
-    lua_rawseti(L, LUA_ENVIRONINDEX, k);
-  }
-  lua_pushvalue(L, -2);  /* copy environment */
-  lua_setfenv(L, -2);  /* set it */
-  lua_setfield(L, -3, fname);
-}
-
-
-static void newfenv (lua_State *L, lua_CFunction cls) {
-  lua_createtable(L, 0, 1);
-  lua_pushcfunction(L, cls);
-  lua_setfield(L, -2, "__close");
-}
-
-
-LUALIB_API int luaopen_io (lua_State *L) {
-  createmeta(L);
-  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
-  newfenv(L, io_fclose);
-  lua_replace(L, LUA_ENVIRONINDEX);
-  /* open library */
-  luaL_register(L, LUA_IOLIBNAME, iolib);
-  /* create (and set) default files */
-  newfenv(L, io_noclose);  /* close function for default files */
-  createstdfile(L, stdin, IO_INPUT, "stdin");
-  createstdfile(L, stdout, IO_OUTPUT, "stdout");
-  createstdfile(L, stderr, 0, "stderr");
-  lua_pop(L, 1);  /* pop environment for default files */
-  lua_getfield(L, -1, "popen");
-  newfenv(L, io_pclose);  /* create environment for 'popen' */
-  lua_setfenv(L, -2);  /* set fenv for 'popen' */
-  lua_pop(L, 1);  /* pop 'popen' */
-  return 1;
-}

diff --git a/source3/lua-5.1.4/src/llex.c b/source3/lua-5.1.4/src/llex.c
deleted file mode 100644 (file)
index e6548f2..0000000
--- a/source3/lua-5.1.4/src/llex.c
+++ /dev/null
@@ -1,460 +0,0 @@
-/*
-** $Id: llex.c,v 2.20.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-
-#include <ctype.h>
-#include <locale.h>
-#include <string.h>
-
-#define llex_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldo.h"
-#include "llex.h"
-#include "lobject.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "lzio.h"
-
-
-
-#define next(ls) (ls->current = zgetc(ls->z))
-
-
-
-
-#define currIsNewline(ls)      (ls->current == '\n' || ls->current == '\r')
-
-
-/* ORDER RESERVED */
-const char *const luaX_tokens [] = {
-    "and", "break", "do", "else", "elseif",
-    "end", "false", "for", "function", "if",
-    "in", "local", "nil", "not", "or", "repeat",
-    "return", "then", "true", "until", "while",
-    "..", "...", "==", ">=", "<=", "~=",
-    "<number>", "<name>", "<string>", "<eof>",
-    NULL
-};
-
-
-#define save_and_next(ls) (save(ls, ls->current), next(ls))
-
-
-static void save (LexState *ls, int c) {
-  Mbuffer *b = ls->buff;
-  if (b->n + 1 > b->buffsize) {
-    size_t newsize;
-    if (b->buffsize >= MAX_SIZET/2)
-      luaX_lexerror(ls, "lexical element too long", 0);
-    newsize = b->buffsize * 2;
-    luaZ_resizebuffer(ls->L, b, newsize);
-  }
-  b->buffer[b->n++] = cast(char, c);
-}
-
-
-void luaX_init (lua_State *L) {
-  int i;
-  for (i=0; i<NUM_RESERVED; i++) {
-    TString *ts = luaS_new(L, luaX_tokens[i]);
-    luaS_fix(ts);  /* reserved words are never collected */
-    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
-    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
-  }
-}
-
-
-#define MAXSRC          80
-
-
-const char *luaX_token2str (LexState *ls, int token) {
-  if (token < FIRST_RESERVED) {
-    lua_assert(token == cast(unsigned char, token));
-    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
-                              luaO_pushfstring(ls->L, "%c", token);
-  }
-  else
-    return luaX_tokens[token-FIRST_RESERVED];
-}
-
-
-static const char *txtToken (LexState *ls, int token) {
-  switch (token) {
-    case TK_NAME:
-    case TK_STRING:
-    case TK_NUMBER:
-      save(ls, '\0');
-      return luaZ_buffer(ls->buff);
-    default:
-      return luaX_token2str(ls, token);
-  }
-}
-
-
-void luaX_lexerror (LexState *ls, const char *msg, int token) {
-  char buff[MAXSRC];
-  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
-  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
-  if (token)
-    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
-  luaD_throw(ls->L, LUA_ERRSYNTAX);
-}
-
-
-void luaX_syntaxerror (LexState *ls, const char *msg) {
-  luaX_lexerror(ls, msg, ls->t.token);
-}
-
-
-TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
-  lua_State *L = ls->L;
-  TString *ts = luaS_newlstr(L, str, l);
-  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
-  if (ttisnil(o))
-    setbvalue(o, 1);  /* make sure `str' will not be collected */
-  return ts;
-}
-
-
-static void inclinenumber (LexState *ls) {
-  int old = ls->current;
-  lua_assert(currIsNewline(ls));
-  next(ls);  /* skip `\n' or `\r' */
-  if (currIsNewline(ls) && ls->current != old)
-    next(ls);  /* skip `\n\r' or `\r\n' */
-  if (++ls->linenumber >= MAX_INT)
-    luaX_syntaxerror(ls, "chunk has too many lines");
-}
-
-
-void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
-  ls->decpoint = '.';
-  ls->L = L;
-  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
-  ls->z = z;
-  ls->fs = NULL;
-  ls->linenumber = 1;
-  ls->lastline = 1;
-  ls->source = source;
-  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
-  next(ls);  /* read first char */
-}
-
-
-
-/*
-** =======================================================
-** LEXICAL ANALYZER
-** =======================================================
-*/
-
-
-
-static int check_next (LexState *ls, const char *set) {
-  if (!strchr(set, ls->current))
-    return 0;
-  save_and_next(ls);
-  return 1;
-}
-
-
-static void buffreplace (LexState *ls, char from, char to) {
-  size_t n = luaZ_bufflen(ls->buff);
-  char *p = luaZ_buffer(ls->buff);
-  while (n--)
-    if (p[n] == from) p[n] = to;
-}
-
-
-static void trydecpoint (LexState *ls, SemInfo *seminfo) {
-  /* format error: try to update decimal point separator */
-  struct lconv *cv = localeconv();
-  char old = ls->decpoint;
-  ls->decpoint = (cv ? cv->decimal_point[0] : '.');
-  buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */
-  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
-    /* format error with correct decimal point: no more options */
-    buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
-    luaX_lexerror(ls, "malformed number", TK_NUMBER);
-  }
-}
-
-
-/* LUA_NUMBER */
-static void read_numeral (LexState *ls, SemInfo *seminfo) {
-  lua_assert(isdigit(ls->current));
-  do {
-    save_and_next(ls);
-  } while (isdigit(ls->current) || ls->current == '.');
-  if (check_next(ls, "Ee"))  /* `E'? */
-    check_next(ls, "+-");  /* optional exponent sign */
-  while (isalnum(ls->current) || ls->current == '_')
-    save_and_next(ls);
-  save(ls, '\0');
-  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
-  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
-    trydecpoint(ls, seminfo); /* try to update decimal point separator */
-}
-
-
-static int skip_sep (LexState *ls) {
-  int count = 0;
-  int s = ls->current;
-  lua_assert(s == '[' || s == ']');
-  save_and_next(ls);
-  while (ls->current == '=') {
-    save_and_next(ls);
-    count++;
-  }
-  return (ls->current == s) ? count : (-count) - 1;
-}
-
-
-static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
-  int cont = 0;
-  (void)(cont);  /* avoid warnings when `cont' is not used */
-  save_and_next(ls);  /* skip 2nd `[' */
-  if (currIsNewline(ls))  /* string starts with a newline? */
-    inclinenumber(ls);  /* skip it */
-  for (;;) {
-    switch (ls->current) {
-      case EOZ:
-        luaX_lexerror(ls, (seminfo) ? "unfinished long string" :
-                                   "unfinished long comment", TK_EOS);
-        break;  /* to avoid warnings */
-#if defined(LUA_COMPAT_LSTR)
-      case '[': {
-        if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd `[' */
-          cont++;
-#if LUA_COMPAT_LSTR == 1
-          if (sep == 0)
-            luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');
-#endif
-        }
-        break;
-      }
-#endif
-      case ']': {
-        if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd `]' */
-#if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2
-          cont--;
-          if (sep == 0 && cont >= 0) break;
-#endif
-          goto endloop;
-        }
-        break;
-      }
-      case '\n':
-      case '\r': {
-        save(ls, '\n');
-        inclinenumber(ls);
-        if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */
-        break;
-      }
-      default: {
-        if (seminfo) save_and_next(ls);
-        else next(ls);
-      }
-    }
-  } endloop:
-  if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
-                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
-}
-
-
-static void read_string (LexState *ls, int del, SemInfo *seminfo) {
-  save_and_next(ls);
-  while (ls->current != del) {
-    switch (ls->current) {
-      case EOZ:
-        luaX_lexerror(ls, "unfinished string", TK_EOS);
-        continue;  /* to avoid warnings */
-      case '\n':
-      case '\r':
-        luaX_lexerror(ls, "unfinished string", TK_STRING);
-        continue;  /* to avoid warnings */
-      case '\\': {
-        int c;
-        next(ls);  /* do not save the `\' */
-        switch (ls->current) {
-          case 'a': c = '\a'; break;
-          case 'b': c = '\b'; break;
-          case 'f': c = '\f'; break;
-          case 'n': c = '\n'; break;
-          case 'r': c = '\r'; break;
-          case 't': c = '\t'; break;
-          case 'v': c = '\v'; break;
-          case '\n':  /* go through */
-          case '\r': save(ls, '\n'); inclinenumber(ls); continue;
-          case EOZ: continue;  /* will raise an error next loop */
-          default: {
-            if (!isdigit(ls->current))
-              save_and_next(ls);  /* handles \\, \", \', and \? */
-            else {  /* \xxx */
-              int i = 0;
-              c = 0;
-              do {
-                c = 10*c + (ls->current-'0');
-                next(ls);
-              } while (++i<3 && isdigit(ls->current));
-              if (c > UCHAR_MAX)
-                luaX_lexerror(ls, "escape sequence too large", TK_STRING);
-              save(ls, c);
-            }
-            continue;
-          }
-        }
-        save(ls, c);
-        next(ls);
-        continue;
-      }
-      default:
-        save_and_next(ls);
-    }
-  }
-  save_and_next(ls);  /* skip delimiter */
-  seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
-                                   luaZ_bufflen(ls->buff) - 2);
-}
-
-
-static int llex (LexState *ls, SemInfo *seminfo) {
-  luaZ_resetbuffer(ls->buff);
-  for (;;) {
-    switch (ls->current) {
-      case '\n':
-      case '\r': {
-        inclinenumber(ls);
-        continue;
-      }
-      case '-': {
-        next(ls);
-        if (ls->current != '-') return '-';
-        /* else is a comment */
-        next(ls);
-        if (ls->current == '[') {
-          int sep = skip_sep(ls);
-          luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
-          if (sep >= 0) {
-            read_long_string(ls, NULL, sep);  /* long comment */
-            luaZ_resetbuffer(ls->buff);
-            continue;
-          }
-        }
-        /* else short comment */
-        while (!currIsNewline(ls) && ls->current != EOZ)
-          next(ls);
-        continue;
-      }
-      case '[': {
-        int sep = skip_sep(ls);
-        if (sep >= 0) {
-          read_long_string(ls, seminfo, sep);
-          return TK_STRING;
-        }
-        else if (sep == -1) return '[';
-        else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
-      }
-      case '=': {
-        next(ls);
-        if (ls->current != '=') return '=';
-        else { next(ls); return TK_EQ; }
-      }
-      case '<': {
-        next(ls);
-        if (ls->current != '=') return '<';
-        else { next(ls); return TK_LE; }
-      }
-      case '>': {
-        next(ls);
-        if (ls->current != '=') return '>';
-        else { next(ls); return TK_GE; }
-      }
-      case '~': {
-        next(ls);
-        if (ls->current != '=') return '~';
-        else { next(ls); return TK_NE; }
-      }
-      case '"':
-      case '\'': {
-        read_string(ls, ls->current, seminfo);
-        return TK_STRING;
-      }
-      case '.': {
-        save_and_next(ls);
-        if (check_next(ls, ".")) {
-          if (check_next(ls, "."))
-            return TK_DOTS;   /* ... */
-          else return TK_CONCAT;   /* .. */
-        }
-        else if (!isdigit(ls->current)) return '.';
-        else {
-          read_numeral(ls, seminfo);
-          return TK_NUMBER;
-        }
-      }
-      case EOZ: {
-        return TK_EOS;
-      }
-      default: {
-        if (isspace(ls->current)) {
-          lua_assert(!currIsNewline(ls));
-          next(ls);
-          continue;
-        }
-        else if (isdigit(ls->current)) {
-          read_numeral(ls, seminfo);
-          return TK_NUMBER;
-        }
-        else if (isalpha(ls->current) || ls->current == '_') {
-          /* identifier or reserved word */
-          TString *ts;
-          do {
-            save_and_next(ls);
-          } while (isalnum(ls->current) || ls->current == '_');
-          ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
-                                  luaZ_bufflen(ls->buff));
-          if (ts->tsv.reserved > 0)  /* reserved word? */
-            return ts->tsv.reserved - 1 + FIRST_RESERVED;
-          else {
-            seminfo->ts = ts;
-            return TK_NAME;
-          }
-        }
-        else {
-          int c = ls->current;
-          next(ls);
-          return c;  /* single-char tokens (+ - / ...) */
-        }
-      }
-    }
-  }
-}
-
-
-void luaX_next (LexState *ls) {
-  ls->lastline = ls->linenumber;
-  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
-    ls->t = ls->lookahead;  /* use this one */
-    ls->lookahead.token = TK_EOS;  /* and discharge it */
-  }
-  else
-    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
-}
-
-
-void luaX_lookahead (LexState *ls) {
-  lua_assert(ls->lookahead.token == TK_EOS);
-  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
-}

diff --git a/source3/lua-5.1.4/src/llex.h b/source3/lua-5.1.4/src/llex.h
deleted file mode 100644 (file)
index a9201ce..0000000
--- a/source3/lua-5.1.4/src/llex.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-#ifndef llex_h
-#define llex_h
-
-#include "lobject.h"
-#include "lzio.h"
-
-
-#define FIRST_RESERVED 257
-
-/* maximum length of a reserved word */
-#define TOKEN_LEN      (sizeof("function")/sizeof(char))
-
-
-/*
-* WARNING: if you change the order of this enumeration,
-* grep "ORDER RESERVED"
-*/
-enum RESERVED {
-  /* terminal symbols denoted by reserved words */
-  TK_AND = FIRST_RESERVED, TK_BREAK,
-  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
-  TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
-  TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
-  /* other terminal symbols */
-  TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
-  TK_NAME, TK_STRING, TK_EOS
-};
-
-/* number of reserved words */
-#define NUM_RESERVED   (cast(int, TK_WHILE-FIRST_RESERVED+1))
-
-
-/* array with token `names' */
-LUAI_DATA const char *const luaX_tokens [];
-
-
-typedef union {
-  lua_Number r;
-  TString *ts;
-} SemInfo;  /* semantics information */
-
-
-typedef struct Token {
-  int token;
-  SemInfo seminfo;
-} Token;
-
-
-typedef struct LexState {
-  int current;  /* current character (charint) */
-  int linenumber;  /* input line counter */
-  int lastline;  /* line of last token `consumed' */
-  Token t;  /* current token */
-  Token lookahead;  /* look ahead token */
-  struct FuncState *fs;  /* `FuncState' is private to the parser */
-  struct lua_State *L;
-  ZIO *z;  /* input stream */
-  Mbuffer *buff;  /* buffer for tokens */
-  TString *source;  /* current source name */
-  char decpoint;  /* locale decimal point */
-} LexState;
-
-
-LUAI_FUNC void luaX_init (lua_State *L);
-LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
-                              TString *source);
-LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
-LUAI_FUNC void luaX_next (LexState *ls);
-LUAI_FUNC void luaX_lookahead (LexState *ls);
-LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);
-LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);
-LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/llimits.h b/source3/lua-5.1.4/src/llimits.h
deleted file mode 100644 (file)
index 20475d4..0000000
--- a/source3/lua-5.1.4/src/llimits.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $
-** Limits, basic types, and some other `installation-dependent' definitions
-** See Copyright Notice in lua.h
-*/
-
-#ifndef llimits_h
-#define llimits_h
-
-
-#include <limits.h>
-#include <stddef.h>
-
-
-#include "lua.h"
-
-
-typedef LUAI_UINT32 lu_int32;
-
-typedef LUAI_UMEM lu_mem;
-
-typedef LUAI_MEM l_mem;
-
-
-
-/* chars used as small naturals (so that `char' is reserved for characters) */
-typedef unsigned char lu_byte;
-
-
-#define MAX_SIZET      ((size_t)(~(size_t)0)-2)
-
-#define MAX_LUMEM      ((lu_mem)(~(lu_mem)0)-2)
-
-
-#define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
-
-/*
-** conversion of pointer to integer
-** this is for hashing only; there is no problem if the integer
-** cannot hold the whole pointer value
-*/
-#define IntPoint(p)  ((unsigned int)(lu_mem)(p))
-
-
-
-/* type to ensure maximum alignment */
-typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
-
-
-/* result of a `usual argument conversion' over lua_Number */
-typedef LUAI_UACNUMBER l_uacNumber;
-
-
-/* internal assertions for in-house debugging */
-#ifdef lua_assert
-
-#define check_exp(c,e)         (lua_assert(c), (e))
-#define api_check(l,e)         lua_assert(e)
-
-#else
-
-#define lua_assert(c)          ((void)0)
-#define check_exp(c,e)         (e)
-#define api_check              luai_apicheck
-
-#endif
-
-
-#ifndef UNUSED
-#define UNUSED(x)      ((void)(x))     /* to avoid warnings */
-#endif
-
-
-#ifndef cast
-#define cast(t, exp)   ((t)(exp))
-#endif
-
-#define cast_byte(i)   cast(lu_byte, (i))
-#define cast_num(i)    cast(lua_Number, (i))
-#define cast_int(i)    cast(int, (i))
-
-
-
-/*
-** type for virtual-machine instructions
-** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
-*/
-typedef lu_int32 Instruction;
-
-
-
-/* maximum stack for a Lua function */
-#define MAXSTACK       250
-
-
-
-/* minimum size for the string table (must be power of 2) */
-#ifndef MINSTRTABSIZE
-#define MINSTRTABSIZE  32
-#endif
-
-
-/* minimum size for string buffer */
-#ifndef LUA_MINBUFFER
-#define LUA_MINBUFFER  32
-#endif
-
-
-#ifndef lua_lock
-#define lua_lock(L)     ((void) 0)
-#define lua_unlock(L)   ((void) 0)
-#endif
-
-#ifndef luai_threadyield
-#define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
-#endif
-
-
-/*
-** macro to control inclusion of some hard tests on stack reallocation
-*/
-#ifndef HARDSTACKTESTS
-#define condhardstacktests(x)  ((void)0)
-#else
-#define condhardstacktests(x)  x
-#endif
-
-#endif

diff --git a/source3/lua-5.1.4/src/lmathlib.c b/source3/lua-5.1.4/src/lmathlib.c
deleted file mode 100644 (file)
index 3c3a35c..0000000
--- a/source3/lua-5.1.4/src/lmathlib.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
-** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
-** Standard mathematical library
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdlib.h>
-#include <math.h>
-
-#define lmathlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#undef PI
-#define PI (3.14159265358979323846)
-#define RADIANS_PER_DEGREE (PI/180.0)
-
-
-
-static int math_abs (lua_State *L) {
-  lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sin (lua_State *L) {
-  lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sinh (lua_State *L) {
-  lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_cos (lua_State *L) {
-  lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_cosh (lua_State *L) {
-  lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tan (lua_State *L) {
-  lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tanh (lua_State *L) {
-  lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_asin (lua_State *L) {
-  lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_acos (lua_State *L) {
-  lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_atan (lua_State *L) {
-  lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_atan2 (lua_State *L) {
-  lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
-  return 1;
-}
-
-static int math_ceil (lua_State *L) {
-  lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_floor (lua_State *L) {
-  lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_fmod (lua_State *L) {
-  lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
-  return 1;
-}
-
-static int math_modf (lua_State *L) {
-  double ip;
-  double fp = modf(luaL_checknumber(L, 1), &ip);
-  lua_pushnumber(L, ip);
-  lua_pushnumber(L, fp);
-  return 2;
-}
-
-static int math_sqrt (lua_State *L) {
-  lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_pow (lua_State *L) {
-  lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
-  return 1;
-}
-
-static int math_log (lua_State *L) {
-  lua_pushnumber(L, log(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_log10 (lua_State *L) {
-  lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_exp (lua_State *L) {
-  lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_deg (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
-  return 1;
-}
-
-static int math_rad (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
-  return 1;
-}
-
-static int math_frexp (lua_State *L) {
-  int e;
-  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
-  lua_pushinteger(L, e);
-  return 2;
-}
-
-static int math_ldexp (lua_State *L) {
-  lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
-  return 1;
-}
-
-
-
-static int math_min (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  lua_Number dmin = luaL_checknumber(L, 1);
-  int i;
-  for (i=2; i<=n; i++) {
-    lua_Number d = luaL_checknumber(L, i);
-    if (d < dmin)
-      dmin = d;
-  }
-  lua_pushnumber(L, dmin);
-  return 1;
-}
-
-
-static int math_max (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  lua_Number dmax = luaL_checknumber(L, 1);
-  int i;
-  for (i=2; i<=n; i++) {
-    lua_Number d = luaL_checknumber(L, i);
-    if (d > dmax)
-      dmax = d;
-  }
-  lua_pushnumber(L, dmax);
-  return 1;
-}
-
-
-static int math_random (lua_State *L) {
-  /* the `%' avoids the (rare) case of r==1, and is needed also because on
-     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
-  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
-  switch (lua_gettop(L)) {  /* check number of arguments */
-    case 0: {  /* no arguments */
-      lua_pushnumber(L, r);  /* Number between 0 and 1 */
-      break;
-    }
-    case 1: {  /* only upper limit */
-      int u = luaL_checkint(L, 1);
-      luaL_argcheck(L, 1<=u, 1, "interval is empty");
-      lua_pushnumber(L, floor(r*u)+1);  /* int between 1 and `u' */
-      break;
-    }
-    case 2: {  /* lower and upper limits */
-      int l = luaL_checkint(L, 1);
-      int u = luaL_checkint(L, 2);
-      luaL_argcheck(L, l<=u, 2, "interval is empty");
-      lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
-      break;
-    }
-    default: return luaL_error(L, "wrong number of arguments");
-  }
-  return 1;
-}
-
-
-static int math_randomseed (lua_State *L) {
-  srand(luaL_checkint(L, 1));
-  return 0;
-}
-
-
-static const luaL_Reg mathlib[] = {
-  {"abs",   math_abs},
-  {"acos",  math_acos},
-  {"asin",  math_asin},
-  {"atan2", math_atan2},
-  {"atan",  math_atan},
-  {"ceil",  math_ceil},
-  {"cosh",   math_cosh},
-  {"cos",   math_cos},
-  {"deg",   math_deg},
-  {"exp",   math_exp},
-  {"floor", math_floor},
-  {"fmod",   math_fmod},
-  {"frexp", math_frexp},
-  {"ldexp", math_ldexp},
-  {"log10", math_log10},
-  {"log",   math_log},
-  {"max",   math_max},
-  {"min",   math_min},
-  {"modf",   math_modf},
-  {"pow",   math_pow},
-  {"rad",   math_rad},
-  {"random",     math_random},
-  {"randomseed", math_randomseed},
-  {"sinh",   math_sinh},
-  {"sin",   math_sin},
-  {"sqrt",  math_sqrt},
-  {"tanh",   math_tanh},
-  {"tan",   math_tan},
-  {NULL, NULL}
-};
-
-
-/*
-** Open math library
-*/
-LUALIB_API int luaopen_math (lua_State *L) {
-  luaL_register(L, LUA_MATHLIBNAME, mathlib);
-  lua_pushnumber(L, PI);
-  lua_setfield(L, -2, "pi");
-  lua_pushnumber(L, HUGE_VAL);
-  lua_setfield(L, -2, "huge");
-#if defined(LUA_COMPAT_MOD)
-  lua_getfield(L, -1, "fmod");
-  lua_setfield(L, -2, "mod");
-#endif
-  return 1;
-}

diff --git a/source3/lua-5.1.4/src/lmem.c b/source3/lua-5.1.4/src/lmem.c
deleted file mode 100644 (file)
index 1b9bed6..0000000
--- a/source3/lua-5.1.4/src/lmem.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-** $Id: lmem.c,v 1.70.1.1 2007/12/27 13:02:25 roberto Exp $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define lmem_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-/*
-** About the realloc function:
-** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
-** (`osize' is the old size, `nsize' is the new size)
-**
-** Lua ensures that (ptr == NULL) iff (osize == 0).
-**
-** * frealloc(ud, NULL, 0, x) creates a new block of size `x'
-**
-** * frealloc(ud, p, x, 0) frees the block `p'
-** (in this specific case, frealloc must return NULL).
-** particularly, frealloc(ud, NULL, 0, 0) does nothing
-** (which is equivalent to free(NULL) in ANSI C)
-**
-** frealloc returns NULL if it cannot create or reallocate the area
-** (any reallocation to an equal or smaller size cannot fail!)
-*/
-
-
-
-#define MINSIZEARRAY   4
-
-
-void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
-                     int limit, const char *errormsg) {
-  void *newblock;
-  int newsize;
-  if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit)  /* cannot grow even a little? */
-      luaG_runerror(L, errormsg);
-    newsize = limit;  /* still have at least one free place */
-  }
-  else {
-    newsize = (*size)*2;
-    if (newsize < MINSIZEARRAY)
-      newsize = MINSIZEARRAY;  /* minimum size */
-  }
-  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
-  *size = newsize;  /* update only when everything else is OK */
-  return newblock;
-}
-
-
-void *luaM_toobig (lua_State *L) {
-  luaG_runerror(L, "memory allocation error: block too big");
-  return NULL;  /* to avoid warnings */
-}
-
-
-
-/*
-** generic allocation routine.
-*/
-void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
-  global_State *g = G(L);
-  lua_assert((osize == 0) == (block == NULL));
-  block = (*g->frealloc)(g->ud, block, osize, nsize);
-  if (block == NULL && nsize > 0)
-    luaD_throw(L, LUA_ERRMEM);
-  lua_assert((nsize == 0) == (block == NULL));
-  g->totalbytes = (g->totalbytes - osize) + nsize;
-  return block;
-}

diff --git a/source3/lua-5.1.4/src/lmem.h b/source3/lua-5.1.4/src/lmem.h
deleted file mode 100644 (file)
index ebfc227..0000000
--- a/source3/lua-5.1.4/src/lmem.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-** $Id: lmem.h,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lmem_h
-#define lmem_h
-
-
-#include <stddef.h>
-
-#include "llimits.h"
-#include "lua.h"
-
-#define MEMERRMSG      "not enough memory"
-
-
-#define luaM_reallocv(L,b,on,n,e) \
-       ((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ?  /* +1 to avoid warnings */ \
-               luaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \
-               luaM_toobig(L))
-
-#define luaM_freemem(L, b, s)  luaM_realloc_(L, (b), (s), 0)
-#define luaM_free(L, b)                luaM_realloc_(L, (b), sizeof(*(b)), 0)
-#define luaM_freearray(L, b, n, t)   luaM_reallocv(L, (b), n, 0, sizeof(t))
-
-#define luaM_malloc(L,t)       luaM_realloc_(L, NULL, 0, (t))
-#define luaM_new(L,t)          cast(t *, luaM_malloc(L, sizeof(t)))
-#define luaM_newvector(L,n,t) \
-               cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
-
-#define luaM_growvector(L,v,nelems,size,t,limit,e) \
-          if ((nelems)+1 > (size)) \
-            ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
-
-#define luaM_reallocvector(L, v,oldn,n,t) \
-   ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
-
-
-LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
-                                                          size_t size);
-LUAI_FUNC void *luaM_toobig (lua_State *L);
-LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
-                               size_t size_elem, int limit,
-                               const char *errormsg);
-
-#endif

diff --git a/source3/lua-5.1.4/src/loadlib.c b/source3/lua-5.1.4/src/loadlib.c
deleted file mode 100644 (file)
index ed1f7af..0000000
--- a/source3/lua-5.1.4/src/loadlib.c
+++ /dev/null
@@ -1,665 +0,0 @@
-/*
-** $Id: loadlib.c,v 1.52.1.3 2008/08/06 13:29:28 roberto Exp $
-** Dynamic library loader for Lua
-** See Copyright Notice in lua.h
-**
-** This module contains an implementation of loadlib for Unix systems
-** that have dlfcn, an implementation for Darwin (Mac OS X), an
-** implementation for Windows, and a stub for other systems.
-*/
-
-
-#include <stdlib.h>
-#include <string.h>
-
-
-#define loadlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/* prefix for open functions in C libraries */
-#define LUA_POF                "luaopen_"
-
-/* separator for open functions in C libraries */
-#define LUA_OFSEP      "_"
-
-
-#define LIBPREFIX      "LOADLIB: "
-
-#define POF            LUA_POF
-#define LIB_FAIL       "open"
-
-
-/* error codes for ll_loadfunc */
-#define ERRLIB         1
-#define ERRFUNC                2
-
-#define setprogdir(L)          ((void)0)
-
-
-static void ll_unloadlib (void *lib);
-static void *ll_load (lua_State *L, const char *path);
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
-
-
-
-#if defined(LUA_DL_DLOPEN)
-/*
-** {========================================================================
-** This is an implementation of loadlib based on the dlfcn interface.
-** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
-** NetBSD, AIX 4.2, HPUX 11, and  probably most other Unix flavors, at least
-** as an emulation layer on top of native functions.
-** =========================================================================
-*/
-
-#include <dlfcn.h>
-
-static void ll_unloadlib (void *lib) {
-  dlclose(lib);
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  void *lib = dlopen(path, RTLD_NOW);
-  if (lib == NULL) lua_pushstring(L, dlerror());
-  return lib;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
-  if (f == NULL) lua_pushstring(L, dlerror());
-  return f;
-}
-
-/* }====================================================== */
-
-
-
-#elif defined(LUA_DL_DLL)
-/*
-** {======================================================================
-** This is an implementation of loadlib for Windows using native functions.
-** =======================================================================
-*/
-
-#include <windows.h>
-
-
-#undef setprogdir
-
-static void setprogdir (lua_State *L) {
-  char buff[MAX_PATH + 1];
-  char *lb;
-  DWORD nsize = sizeof(buff)/sizeof(char);
-  DWORD n = GetModuleFileNameA(NULL, buff, nsize);
-  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
-    luaL_error(L, "unable to get ModuleFileName");
-  else {
-    *lb = '\0';
-    luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
-    lua_remove(L, -2);  /* remove original string */
-  }
-}
-
-
-static void pusherror (lua_State *L) {
-  int error = GetLastError();
-  char buffer[128];
-  if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
-      NULL, error, 0, buffer, sizeof(buffer), NULL))
-    lua_pushstring(L, buffer);
-  else
-    lua_pushfstring(L, "system error %d\n", error);
-}
-
-static void ll_unloadlib (void *lib) {
-  FreeLibrary((HINSTANCE)lib);
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  HINSTANCE lib = LoadLibraryA(path);
-  if (lib == NULL) pusherror(L);
-  return lib;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)GetProcAddress((HINSTANCE)lib, sym);
-  if (f == NULL) pusherror(L);
-  return f;
-}
-
-/* }====================================================== */
-
-
-
-#elif defined(LUA_DL_DYLD)
-/*
-** {======================================================================
-** Native Mac OS X / Darwin Implementation
-** =======================================================================
-*/
-
-#include <mach-o/dyld.h>
-
-
-/* Mac appends a `_' before C function names */
-#undef POF
-#define POF    "_" LUA_POF
-
-
-static void pusherror (lua_State *L) {
-  const char *err_str;
-  const char *err_file;
-  NSLinkEditErrors err;
-  int err_num;
-  NSLinkEditError(&err, &err_num, &err_file, &err_str);
-  lua_pushstring(L, err_str);
-}
-
-
-static const char *errorfromcode (NSObjectFileImageReturnCode ret) {
-  switch (ret) {
-    case NSObjectFileImageInappropriateFile:
-      return "file is not a bundle";
-    case NSObjectFileImageArch:
-      return "library is for wrong CPU type";
-    case NSObjectFileImageFormat:
-      return "bad format";
-    case NSObjectFileImageAccess:
-      return "cannot access file";
-    case NSObjectFileImageFailure:
-    default:
-      return "unable to load library";
-  }
-}
-
-
-static void ll_unloadlib (void *lib) {
-  NSUnLinkModule((NSModule)lib, NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  NSObjectFileImage img;
-  NSObjectFileImageReturnCode ret;
-  /* this would be a rare case, but prevents crashing if it happens */
-  if(!_dyld_present()) {
-    lua_pushliteral(L, "dyld not present");
-    return NULL;
-  }
-  ret = NSCreateObjectFileImageFromFile(path, &img);
-  if (ret == NSObjectFileImageSuccess) {
-    NSModule mod = NSLinkModule(img, path, NSLINKMODULE_OPTION_PRIVATE |
-                       NSLINKMODULE_OPTION_RETURN_ON_ERROR);
-    NSDestroyObjectFileImage(img);
-    if (mod == NULL) pusherror(L);
-    return mod;
-  }
-  lua_pushstring(L, errorfromcode(ret));
-  return NULL;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  NSSymbol nss = NSLookupSymbolInModule((NSModule)lib, sym);
-  if (nss == NULL) {
-    lua_pushfstring(L, "symbol " LUA_QS " not found", sym);
-    return NULL;
-  }
-  return (lua_CFunction)NSAddressOfSymbol(nss);
-}
-
-/* }====================================================== */
-
-
-
-#else
-/*
-** {======================================================
-** Fallback for other systems
-** =======================================================
-*/
-
-#undef LIB_FAIL
-#define LIB_FAIL       "absent"
-
-
-#define DLMSG  "dynamic libraries not enabled; check your Lua installation"
-
-
-static void ll_unloadlib (void *lib) {
-  (void)lib;  /* to avoid warnings */
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  (void)path;  /* to avoid warnings */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  (void)lib; (void)sym;  /* to avoid warnings */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-/* }====================================================== */
-#endif
-
-
-
-static void **ll_register (lua_State *L, const char *path) {
-  void **plib;
-  lua_pushfstring(L, "%s%s", LIBPREFIX, path);
-  lua_gettable(L, LUA_REGISTRYINDEX);  /* check library in registry? */
-  if (!lua_isnil(L, -1))  /* is there an entry? */
-    plib = (void **)lua_touserdata(L, -1);
-  else {  /* no entry yet; create one */
-    lua_pop(L, 1);
-    plib = (void **)lua_newuserdata(L, sizeof(const void *));
-    *plib = NULL;
-    luaL_getmetatable(L, "_LOADLIB");
-    lua_setmetatable(L, -2);
-    lua_pushfstring(L, "%s%s", LIBPREFIX, path);
-    lua_pushvalue(L, -2);
-    lua_settable(L, LUA_REGISTRYINDEX);
-  }
-  return plib;
-}
-
-
-/*
-** __gc tag method: calls library's `ll_unloadlib' function with the lib
-** handle
-*/
-static int gctm (lua_State *L) {
-  void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
-  if (*lib) ll_unloadlib(*lib);
-  *lib = NULL;  /* mark library as closed */
-  return 0;
-}
-
-
-static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
-  void **reg = ll_register(L, path);
-  if (*reg == NULL) *reg = ll_load(L, path);
-  if (*reg == NULL)
-    return ERRLIB;  /* unable to load library */
-  else {
-    lua_CFunction f = ll_sym(L, *reg, sym);
-    if (f == NULL)
-      return ERRFUNC;  /* unable to find function */
-    lua_pushcfunction(L, f);
-    return 0;  /* return function */
-  }
-}
-
-
-static int ll_loadlib (lua_State *L) {
-  const char *path = luaL_checkstring(L, 1);
-  const char *init = luaL_checkstring(L, 2);
-  int stat = ll_loadfunc(L, path, init);
-  if (stat == 0)  /* no errors? */
-    return 1;  /* return the loaded function */
-  else {  /* error; error message is on stack top */
-    lua_pushnil(L);
-    lua_insert(L, -2);
-    lua_pushstring(L, (stat == ERRLIB) ?  LIB_FAIL : "init");
-    return 3;  /* return nil, error message, and where */
-  }
-}
-
-
-
-/*
-** {======================================================
-** 'require' function
-** =======================================================
-*/
-
-
-static int readable (const char *filename) {
-  FILE *f = fopen(filename, "r");  /* try to open file */
-  if (f == NULL) return 0;  /* open failed */
-  fclose(f);
-  return 1;
-}
-
-
-static const char *pushnexttemplate (lua_State *L, const char *path) {
-  const char *l;
-  while (*path == *LUA_PATHSEP) path++;  /* skip separators */
-  if (*path == '\0') return NULL;  /* no more templates */
-  l = strchr(path, *LUA_PATHSEP);  /* find next separator */
-  if (l == NULL) l = path + strlen(path);
-  lua_pushlstring(L, path, l - path);  /* template */
-  return l;
-}
-
-
-static const char *findfile (lua_State *L, const char *name,
-                                           const char *pname) {
-  const char *path;
-  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
-  lua_getfield(L, LUA_ENVIRONINDEX, pname);
-  path = lua_tostring(L, -1);
-  if (path == NULL)
-    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
-  lua_pushliteral(L, "");  /* error accumulator */
-  while ((path = pushnexttemplate(L, path)) != NULL) {
-    const char *filename;
-    filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
-    lua_remove(L, -2);  /* remove path template */
-    if (readable(filename))  /* does file exist and is readable? */
-      return filename;  /* return that file name */
-    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
-    lua_remove(L, -2);  /* remove file name */
-    lua_concat(L, 2);  /* add entry to possible error message */
-  }
-  return NULL;  /* not found */
-}
-
-
-static void loaderror (lua_State *L, const char *filename) {
-  luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
-                lua_tostring(L, 1), filename, lua_tostring(L, -1));
-}
-
-
-static int loader_Lua (lua_State *L) {
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  filename = findfile(L, name, "path");
-  if (filename == NULL) return 1;  /* library not found in this path */
-  if (luaL_loadfile(L, filename) != 0)
-    loaderror(L, filename);
-  return 1;  /* library loaded successfully */
-}
-
-
-static const char *mkfuncname (lua_State *L, const char *modname) {
-  const char *funcname;
-  const char *mark = strchr(modname, *LUA_IGMARK);
-  if (mark) modname = mark + 1;
-  funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
-  funcname = lua_pushfstring(L, POF"%s", funcname);
-  lua_remove(L, -2);  /* remove 'gsub' result */
-  return funcname;
-}
-
-
-static int loader_C (lua_State *L) {
-  const char *funcname;
-  const char *name = luaL_checkstring(L, 1);
-  const char *filename = findfile(L, name, "cpath");
-  if (filename == NULL) return 1;  /* library not found in this path */
-  funcname = mkfuncname(L, name);
-  if (ll_loadfunc(L, filename, funcname) != 0)
-    loaderror(L, filename);
-  return 1;  /* library loaded successfully */
-}
-
-
-static int loader_Croot (lua_State *L) {
-  const char *funcname;
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  const char *p = strchr(name, '.');
-  int stat;
-  if (p == NULL) return 0;  /* is root */
-  lua_pushlstring(L, name, p - name);
-  filename = findfile(L, lua_tostring(L, -1), "cpath");
-  if (filename == NULL) return 1;  /* root not found */
-  funcname = mkfuncname(L, name);
-  if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
-    if (stat != ERRFUNC) loaderror(L, filename);  /* real error */
-    lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
-                       name, filename);
-    return 1;  /* function not found */
-  }
-  return 1;
-}
-
-
-static int loader_preload (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  lua_getfield(L, LUA_ENVIRONINDEX, "preload");
-  if (!lua_istable(L, -1))
-    luaL_error(L, LUA_QL("package.preload") " must be a table");
-  lua_getfield(L, -1, name);
-  if (lua_isnil(L, -1))  /* not found? */
-    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
-  return 1;
-}
-
-
-static const int sentinel_ = 0;
-#define sentinel       ((void *)&sentinel_)
-
-
-static int ll_require (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  int i;
-  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, 2, name);
-  if (lua_toboolean(L, -1)) {  /* is it there? */
-    if (lua_touserdata(L, -1) == sentinel)  /* check loops */
-      luaL_error(L, "loop or previous error loading module " LUA_QS, name);
-    return 1;  /* package is already loaded */
-  }
-  /* else must load it; iterate over available loaders */
-  lua_getfield(L, LUA_ENVIRONINDEX, "loaders");
-  if (!lua_istable(L, -1))
-    luaL_error(L, LUA_QL("package.loaders") " must be a table");
-  lua_pushliteral(L, "");  /* error message accumulator */
-  for (i=1; ; i++) {
-    lua_rawgeti(L, -2, i);  /* get a loader */
-    if (lua_isnil(L, -1))
-      luaL_error(L, "module " LUA_QS " not found:%s",
-                    name, lua_tostring(L, -2));
-    lua_pushstring(L, name);
-    lua_call(L, 1, 1);  /* call it */
-    if (lua_isfunction(L, -1))  /* did it find module? */
-      break;  /* module loaded successfully */
-    else if (lua_isstring(L, -1))  /* loader returned error message? */
-      lua_concat(L, 2);  /* accumulate it */
-    else
-      lua_pop(L, 1);
-  }
-  lua_pushlightuserdata(L, sentinel);
-  lua_setfield(L, 2, name);  /* _LOADED[name] = sentinel */
-  lua_pushstring(L, name);  /* pass name as argument to module */
-  lua_call(L, 1, 1);  /* run loaded module */
-  if (!lua_isnil(L, -1))  /* non-nil return? */
-    lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
-  lua_getfield(L, 2, name);
-  if (lua_touserdata(L, -1) == sentinel) {   /* module did not set a value? */
-    lua_pushboolean(L, 1);  /* use true as result */
-    lua_pushvalue(L, -1);  /* extra copy to be returned */
-    lua_setfield(L, 2, name);  /* _LOADED[name] = true */
-  }
-  return 1;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** 'module' function
-** =======================================================
-*/
-
-
-static void setfenv (lua_State *L) {
-  lua_Debug ar;
-  if (lua_getstack(L, 1, &ar) == 0 ||
-      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
-      lua_iscfunction(L, -1))
-    luaL_error(L, LUA_QL("module") " not called from a Lua function");
-  lua_pushvalue(L, -2);
-  lua_setfenv(L, -2);
-  lua_pop(L, 1);
-}
-
-
-static void dooptions (lua_State *L, int n) {
-  int i;
-  for (i = 2; i <= n; i++) {
-    lua_pushvalue(L, i);  /* get option (a function) */
-    lua_pushvalue(L, -2);  /* module */
-    lua_call(L, 1, 0);
-  }
-}
-
-
-static void modinit (lua_State *L, const char *modname) {
-  const char *dot;
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -2, "_M");  /* module._M = module */
-  lua_pushstring(L, modname);
-  lua_setfield(L, -2, "_NAME");
-  dot = strrchr(modname, '.');  /* look for last dot in module name */
-  if (dot == NULL) dot = modname;
-  else dot++;
-  /* set _PACKAGE as package name (full module name minus last part) */
-  lua_pushlstring(L, modname, dot - modname);
-  lua_setfield(L, -2, "_PACKAGE");
-}
-
-
-static int ll_module (lua_State *L) {
-  const char *modname = luaL_checkstring(L, 1);
-  int loaded = lua_gettop(L) + 1;  /* index of _LOADED table */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, loaded, modname);  /* get _LOADED[modname] */
-  if (!lua_istable(L, -1)) {  /* not found? */
-    lua_pop(L, 1);  /* remove previous result */
-    /* try global variable (and create one if it does not exist) */
-    if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
-      return luaL_error(L, "name conflict for module " LUA_QS, modname);
-    lua_pushvalue(L, -1);
-    lua_setfield(L, loaded, modname);  /* _LOADED[modname] = new table */
-  }
-  /* check whether table already has a _NAME field */
-  lua_getfield(L, -1, "_NAME");
-  if (!lua_isnil(L, -1))  /* is table an initialized module? */
-    lua_pop(L, 1);
-  else {  /* no; initialize it */
-    lua_pop(L, 1);
-    modinit(L, modname);
-  }
-  lua_pushvalue(L, -1);
-  setfenv(L);
-  dooptions(L, loaded - 1);
-  return 0;
-}
-
-
-static int ll_seeall (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  if (!lua_getmetatable(L, 1)) {
-    lua_createtable(L, 0, 1); /* create new metatable */
-    lua_pushvalue(L, -1);
-    lua_setmetatable(L, 1);
-  }
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
-  return 0;
-}
-
-
-/* }====================================================== */
-
-
-
-/* auxiliary mark (for internal use) */
-#define AUXMARK                "\1"
-
-static void setpath (lua_State *L, const char *fieldname, const char *envname,
-                                   const char *def) {
-  const char *path = getenv(envname);
-  if (path == NULL)  /* no environment variable? */
-    lua_pushstring(L, def);  /* use default */
-  else {
-    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
-    path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
-                              LUA_PATHSEP AUXMARK LUA_PATHSEP);
-    luaL_gsub(L, path, AUXMARK, def);
-    lua_remove(L, -2);
-  }
-  setprogdir(L);
-  lua_setfield(L, -2, fieldname);
-}
-
-
-static const luaL_Reg pk_funcs[] = {
-  {"loadlib", ll_loadlib},
-  {"seeall", ll_seeall},
-  {NULL, NULL}
-};
-
-
-static const luaL_Reg ll_funcs[] = {
-  {"module", ll_module},
-  {"require", ll_require},
-  {NULL, NULL}
-};
-
-
-static const lua_CFunction loaders[] =
-  {loader_preload, loader_Lua, loader_C, loader_Croot, NULL};
-
-
-LUALIB_API int luaopen_package (lua_State *L) {
-  int i;
-  /* create new type _LOADLIB */
-  luaL_newmetatable(L, "_LOADLIB");
-  lua_pushcfunction(L, gctm);
-  lua_setfield(L, -2, "__gc");
-  /* create `package' table */
-  luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
-#if defined(LUA_COMPAT_LOADLIB)
-  lua_getfield(L, -1, "loadlib");
-  lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
-#endif
-  lua_pushvalue(L, -1);
-  lua_replace(L, LUA_ENVIRONINDEX);
-  /* create `loaders' table */
-  lua_createtable(L, 0, sizeof(loaders)/sizeof(loaders[0]) - 1);
-  /* fill it with pre-defined loaders */
-  for (i=0; loaders[i] != NULL; i++) {
-    lua_pushcfunction(L, loaders[i]);
-    lua_rawseti(L, -2, i+1);
-  }
-  lua_setfield(L, -2, "loaders");  /* put it in field `loaders' */
-  setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT);  /* set field `path' */
-  setpath(L, "cpath", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */
-  /* store config information */
-  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
-                     LUA_EXECDIR "\n" LUA_IGMARK);
-  lua_setfield(L, -2, "config");
-  /* set field `loaded' */
-  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
-  lua_setfield(L, -2, "loaded");
-  /* set field `preload' */
-  lua_newtable(L);
-  lua_setfield(L, -2, "preload");
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  luaL_register(L, NULL, ll_funcs);  /* open lib into global table */
-  lua_pop(L, 1);
-  return 1;  /* return 'package' table */
-}

diff --git a/source3/lua-5.1.4/src/lobject.c b/source3/lua-5.1.4/src/lobject.c
deleted file mode 100644 (file)
index 4ff5073..0000000
--- a/source3/lua-5.1.4/src/lobject.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $
-** Some generic functions over Lua objects
-** See Copyright Notice in lua.h
-*/
-
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lobject_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "lvm.h"
-
-
-
-const TValue luaO_nilobject_ = {{NULL}, LUA_TNIL};
-
-
-/*
-** converts an integer to a "floating point byte", represented as
-** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
-** eeeee != 0 and (xxx) otherwise.
-*/
-int luaO_int2fb (unsigned int x) {
-  int e = 0;  /* expoent */
-  while (x >= 16) {
-    x = (x+1) >> 1;
-    e++;
-  }
-  if (x < 8) return x;
-  else return ((e+1) << 3) | (cast_int(x) - 8);
-}
-
-
-/* converts back */
-int luaO_fb2int (int x) {
-  int e = (x >> 3) & 31;
-  if (e == 0) return x;
-  else return ((x & 7)+8) << (e - 1);
-}
-
-
-int luaO_log2 (unsigned int x) {
-  static const lu_byte log_2[256] = {
-    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
-  };
-  int l = -1;
-  while (x >= 256) { l += 8; x >>= 8; }
-  return l + log_2[x];
-
-}
-
-
-int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
-  if (ttype(t1) != ttype(t2)) return 0;
-  else switch (ttype(t1)) {
-    case LUA_TNIL:
-      return 1;
-    case LUA_TNUMBER:
-      return luai_numeq(nvalue(t1), nvalue(t2));
-    case LUA_TBOOLEAN:
-      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
-    case LUA_TLIGHTUSERDATA:
-      return pvalue(t1) == pvalue(t2);
-    default:
-      lua_assert(iscollectable(t1));
-      return gcvalue(t1) == gcvalue(t2);
-  }
-}
-
-
-int luaO_str2d (const char *s, lua_Number *result) {
-  char *endptr;
-  *result = lua_str2number(s, &endptr);
-  if (endptr == s) return 0;  /* conversion failed */
-  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
-    *result = cast_num(strtoul(s, &endptr, 16));
-  if (*endptr == '\0') return 1;  /* most common case */
-  while (isspace(cast(unsigned char, *endptr))) endptr++;
-  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
-  return 1;
-}
-
-
-
-static void pushstr (lua_State *L, const char *str) {
-  setsvalue2s(L, L->top, luaS_new(L, str));
-  incr_top(L);
-}
-
-
-/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
-const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
-  int n = 1;
-  pushstr(L, "");
-  for (;;) {
-    const char *e = strchr(fmt, '%');
-    if (e == NULL) break;
-    setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
-    incr_top(L);
-    switch (*(e+1)) {
-      case 's': {
-        const char *s = va_arg(argp, char *);
-        if (s == NULL) s = "(null)";
-        pushstr(L, s);
-        break;
-      }
-      case 'c': {
-        char buff[2];
-        buff[0] = cast(char, va_arg(argp, int));
-        buff[1] = '\0';
-        pushstr(L, buff);
-        break;
-      }
-      case 'd': {
-        setnvalue(L->top, cast_num(va_arg(argp, int)));
-        incr_top(L);
-        break;
-      }
-      case 'f': {
-        setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
-        incr_top(L);
-        break;
-      }
-      case 'p': {
-        char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
-        sprintf(buff, "%p", va_arg(argp, void *));
-        pushstr(L, buff);
-        break;
-      }
-      case '%': {
-        pushstr(L, "%");
-        break;
-      }
-      default: {
-        char buff[3];
-        buff[0] = '%';
-        buff[1] = *(e+1);
-        buff[2] = '\0';
-        pushstr(L, buff);
-        break;
-      }
-    }
-    n += 2;
-    fmt = e+2;
-  }
-  pushstr(L, fmt);
-  luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);
-  L->top -= n;
-  return svalue(L->top - 1);
-}
-
-
-const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
-  const char *msg;
-  va_list argp;
-  va_start(argp, fmt);
-  msg = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  return msg;
-}
-
-
-void luaO_chunkid (char *out, const char *source, size_t bufflen) {
-  if (*source == '=') {
-    strncpy(out, source+1, bufflen);  /* remove first char */
-    out[bufflen-1] = '\0';  /* ensures null termination */
-  }
-  else {  /* out = "source", or "...source" */
-    if (*source == '@') {
-      size_t l;
-      source++;  /* skip the `@' */
-      bufflen -= sizeof(" '...' ");
-      l = strlen(source);
-      strcpy(out, "");
-      if (l > bufflen) {
-        source += (l-bufflen);  /* get last part of file name */
-        strcat(out, "...");
-      }
-      strcat(out, source);
-    }
-    else {  /* out = [string "string"] */
-      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
-      bufflen -= sizeof(" [string \"...\"] ");
-      if (len > bufflen) len = bufflen;
-      strcpy(out, "[string \"");
-      if (source[len] != '\0') {  /* must truncate? */
-        strncat(out, source, len);
-        strcat(out, "...");
-      }
-      else
-        strcat(out, source);
-      strcat(out, "\"]");
-    }
-  }
-}

diff --git a/source3/lua-5.1.4/src/lobject.h b/source3/lua-5.1.4/src/lobject.h
deleted file mode 100644 (file)
index 31d0454..0000000
--- a/source3/lua-5.1.4/src/lobject.h
+++ /dev/null
@@ -1,380 +0,0 @@
-/*
-** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $
-** Type definitions for Lua objects
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lobject_h
-#define lobject_h
-
-
-#include <stdarg.h>
-
-
-#include "llimits.h"
-#include "lua.h"
-
-
-/* tags for values visible from Lua */
-#define LAST_TAG       LUA_TTHREAD
-
-#define NUM_TAGS       (LAST_TAG+1)
-
-
-/*
-** Extra tags for non-values
-*/
-#define LUA_TPROTO     (LAST_TAG+1)
-#define LUA_TUPVAL     (LAST_TAG+2)
-#define LUA_TDEADKEY   (LAST_TAG+3)
-
-
-/*
-** Union of all collectable objects
-*/
-typedef union GCObject GCObject;
-
-
-/*
-** Common Header for all collectable objects (in macro form, to be
-** included in other objects)
-*/
-#define CommonHeader   GCObject *next; lu_byte tt; lu_byte marked
-
-
-/*
-** Common header in struct form
-*/
-typedef struct GCheader {
-  CommonHeader;
-} GCheader;
-
-
-
-
-/*
-** Union of all Lua values
-*/
-typedef union {
-  GCObject *gc;
-  void *p;
-  lua_Number n;
-  int b;
-} Value;
-
-
-/*
-** Tagged Values
-*/
-
-#define TValuefields   Value value; int tt
-
-typedef struct lua_TValue {
-  TValuefields;
-} TValue;
-
-
-/* Macros to test type */
-#define ttisnil(o)     (ttype(o) == LUA_TNIL)
-#define ttisnumber(o)  (ttype(o) == LUA_TNUMBER)
-#define ttisstring(o)  (ttype(o) == LUA_TSTRING)
-#define ttistable(o)   (ttype(o) == LUA_TTABLE)
-#define ttisfunction(o)        (ttype(o) == LUA_TFUNCTION)
-#define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN)
-#define ttisuserdata(o)        (ttype(o) == LUA_TUSERDATA)
-#define ttisthread(o)  (ttype(o) == LUA_TTHREAD)
-#define ttislightuserdata(o)   (ttype(o) == LUA_TLIGHTUSERDATA)
-
-/* Macros to access values */
-#define ttype(o)       ((o)->tt)
-#define gcvalue(o)     check_exp(iscollectable(o), (o)->value.gc)
-#define pvalue(o)      check_exp(ttislightuserdata(o), (o)->value.p)
-#define nvalue(o)      check_exp(ttisnumber(o), (o)->value.n)
-#define rawtsvalue(o)  check_exp(ttisstring(o), &(o)->value.gc->ts)
-#define tsvalue(o)     (&rawtsvalue(o)->tsv)
-#define rawuvalue(o)   check_exp(ttisuserdata(o), &(o)->value.gc->u)
-#define uvalue(o)      (&rawuvalue(o)->uv)
-#define clvalue(o)     check_exp(ttisfunction(o), &(o)->value.gc->cl)
-#define hvalue(o)      check_exp(ttistable(o), &(o)->value.gc->h)
-#define bvalue(o)      check_exp(ttisboolean(o), (o)->value.b)
-#define thvalue(o)     check_exp(ttisthread(o), &(o)->value.gc->th)
-
-#define l_isfalse(o)   (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
-
-/*
-** for internal debug only
-*/
-#define checkconsistency(obj) \
-  lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
-
-#define checkliveness(g,obj) \
-  lua_assert(!iscollectable(obj) || \
-  ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))
-
-
-/* Macros to set values */
-#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
-
-#define setnvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
-
-#define setpvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }
-
-#define setbvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
-
-#define setsvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \
-    checkliveness(G(L),i_o); }
-
-#define setuvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \
-    checkliveness(G(L),i_o); }
-
-#define setthvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \
-    checkliveness(G(L),i_o); }
-
-#define setclvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \
-    checkliveness(G(L),i_o); }
-
-#define sethvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \
-    checkliveness(G(L),i_o); }
-
-#define setptvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \
-    checkliveness(G(L),i_o); }
-
-
-
-
-#define setobj(L,obj1,obj2) \
-  { const TValue *o2=(obj2); TValue *o1=(obj1); \
-    o1->value = o2->value; o1->tt=o2->tt; \
-    checkliveness(G(L),o1); }
-
-
-/*
-** different types of sets, according to destination
-*/
-
-/* from stack to (same) stack */
-#define setobjs2s      setobj
-/* to stack (not from same stack) */
-#define setobj2s       setobj
-#define setsvalue2s    setsvalue
-#define sethvalue2s    sethvalue
-#define setptvalue2s   setptvalue
-/* from table to same table */
-#define setobjt2t      setobj
-/* to table */
-#define setobj2t       setobj
-/* to new object */
-#define setobj2n       setobj
-#define setsvalue2n    setsvalue
-
-#define setttype(obj, tt) (ttype(obj) = (tt))
-
-
-#define iscollectable(o)       (ttype(o) >= LUA_TSTRING)
-
-
-
-typedef TValue *StkId;  /* index to stack elements */
-
-
-/*
-** String headers for string table
-*/
-typedef union TString {
-  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
-  struct {
-    CommonHeader;
-    lu_byte reserved;
-    unsigned int hash;
-    size_t len;
-  } tsv;
-} TString;
-
-
-#define getstr(ts)     cast(const char *, (ts) + 1)
-#define svalue(o)       getstr(rawtsvalue(o))
-
-
-
-typedef union Udata {
-  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
-  struct {
-    CommonHeader;
-    struct Table *metatable;
-    struct Table *env;
-    size_t len;
-  } uv;
-} Udata;
-
-
-
-
-/*
-** Function Prototypes
-*/
-typedef struct Proto {
-  CommonHeader;
-  TValue *k;  /* constants used by the function */
-  Instruction *code;
-  struct Proto **p;  /* functions defined inside the function */
-  int *lineinfo;  /* map from opcodes to source lines */
-  struct LocVar *locvars;  /* information about local variables */
-  TString **upvalues;  /* upvalue names */
-  TString  *source;
-  int sizeupvalues;
-  int sizek;  /* size of `k' */
-  int sizecode;
-  int sizelineinfo;
-  int sizep;  /* size of `p' */
-  int sizelocvars;
-  int linedefined;
-  int lastlinedefined;
-  GCObject *gclist;
-  lu_byte nups;  /* number of upvalues */
-  lu_byte numparams;
-  lu_byte is_vararg;
-  lu_byte maxstacksize;
-} Proto;
-
-
-/* masks for new-style vararg */
-#define VARARG_HASARG          1
-#define VARARG_ISVARARG                2
-#define VARARG_NEEDSARG                4
-
-
-typedef struct LocVar {
-  TString *varname;
-  int startpc;  /* first point where variable is active */
-  int endpc;    /* first point where variable is dead */
-} LocVar;
-
-
-
-/*
-** Upvalues
-*/
-
-typedef struct UpVal {
-  CommonHeader;
-  TValue *v;  /* points to stack or to its own value */
-  union {
-    TValue value;  /* the value (when closed) */
-    struct {  /* double linked list (when open) */
-      struct UpVal *prev;
-      struct UpVal *next;
-    } l;
-  } u;
-} UpVal;
-
-
-/*
-** Closures
-*/
-
-#define ClosureHeader \
-       CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
-       struct Table *env
-
-typedef struct CClosure {
-  ClosureHeader;
-  lua_CFunction f;
-  TValue upvalue[1];
-} CClosure;
-
-
-typedef struct LClosure {
-  ClosureHeader;
-  struct Proto *p;
-  UpVal *upvals[1];
-} LClosure;
-
-
-typedef union Closure {
-  CClosure c;
-  LClosure l;
-} Closure;
-
-
-#define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
-#define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
-
-
-/*
-** Tables
-*/
-
-typedef union TKey {
-  struct {
-    TValuefields;
-    struct Node *next;  /* for chaining */
-  } nk;
-  TValue tvk;
-} TKey;
-
-
-typedef struct Node {
-  TValue i_val;
-  TKey i_key;
-} Node;
-
-
-typedef struct Table {
-  CommonHeader;
-  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
-  lu_byte lsizenode;  /* log2 of size of `node' array */
-  struct Table *metatable;
-  TValue *array;  /* array part */
-  Node *node;
-  Node *lastfree;  /* any free position is before this position */
-  GCObject *gclist;
-  int sizearray;  /* size of `array' array */
-} Table;
-
-
-
-/*
-** `module' operation for hashing (size is always a power of 2)
-*/
-#define lmod(s,size) \
-       (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
-
-
-#define twoto(x)       (1<<(x))
-#define sizenode(t)    (twoto((t)->lsizenode))
-
-
-#define luaO_nilobject         (&luaO_nilobject_)
-
-LUAI_DATA const TValue luaO_nilobject_;
-
-#define ceillog2(x)    (luaO_log2((x)-1) + 1)
-
-LUAI_FUNC int luaO_log2 (unsigned int x);
-LUAI_FUNC int luaO_int2fb (unsigned int x);
-LUAI_FUNC int luaO_fb2int (int x);
-LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
-LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
-LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
-                                                       va_list argp);
-LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
-LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/lopcodes.c b/source3/lua-5.1.4/src/lopcodes.c
deleted file mode 100644 (file)
index 0d5f0be..0000000
--- a/source3/lua-5.1.4/src/lopcodes.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
-** See Copyright Notice in lua.h
-*/
-
-
-#define lopcodes_c
-#define LUA_CORE
-
-
-#include "lopcodes.h"
-
-
-/* ORDER OP */
-
-const char *const luaP_opnames[NUM_OPCODES+1] = {
-  "MOVE",
-  "LOADK",
-  "LOADBOOL",
-  "LOADNIL",
-  "GETUPVAL",
-  "GETGLOBAL",
-  "GETTABLE",
-  "SETGLOBAL",
-  "SETUPVAL",
-  "SETTABLE",
-  "NEWTABLE",
-  "SELF",
-  "ADD",
-  "SUB",
-  "MUL",
-  "DIV",
-  "MOD",
-  "POW",
-  "UNM",
-  "NOT",
-  "LEN",
-  "CONCAT",
-  "JMP",
-  "EQ",
-  "LT",
-  "LE",
-  "TEST",
-  "TESTSET",
-  "CALL",
-  "TAILCALL",
-  "RETURN",
-  "FORLOOP",
-  "FORPREP",
-  "TFORLOOP",
-  "SETLIST",
-  "CLOSE",
-  "CLOSURE",
-  "VARARG",
-  NULL
-};
-
-
-#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
-
-const lu_byte luaP_opmodes[NUM_OPCODES] = {
-/*       T  A    B       C     mode               opcode       */
-  opmode(0, 1, OpArgR, OpArgN, iABC)           /* OP_MOVE */
- ,opmode(0, 1, OpArgK, OpArgN, iABx)           /* OP_LOADK */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)           /* OP_LOADBOOL */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)           /* OP_LOADNIL */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)           /* OP_GETUPVAL */
- ,opmode(0, 1, OpArgK, OpArgN, iABx)           /* OP_GETGLOBAL */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)           /* OP_GETTABLE */
- ,opmode(0, 0, OpArgK, OpArgN, iABx)           /* OP_SETGLOBAL */
- ,opmode(0, 0, OpArgU, OpArgN, iABC)           /* OP_SETUPVAL */
- ,opmode(0, 0, OpArgK, OpArgK, iABC)           /* OP_SETTABLE */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)           /* OP_NEWTABLE */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)           /* OP_SELF */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)           /* OP_ADD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)           /* OP_SUB */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)           /* OP_MUL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)           /* OP_DIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)           /* OP_MOD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)           /* OP_POW */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)           /* OP_UNM */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)           /* OP_NOT */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)           /* OP_LEN */
- ,opmode(0, 1, OpArgR, OpArgR, iABC)           /* OP_CONCAT */
- ,opmode(0, 0, OpArgR, OpArgN, iAsBx)          /* OP_JMP */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)           /* OP_EQ */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)           /* OP_LT */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)           /* OP_LE */
- ,opmode(1, 1, OpArgR, OpArgU, iABC)           /* OP_TEST */
- ,opmode(1, 1, OpArgR, OpArgU, iABC)           /* OP_TESTSET */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)           /* OP_CALL */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)           /* OP_TAILCALL */
- ,opmode(0, 0, OpArgU, OpArgN, iABC)           /* OP_RETURN */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)          /* OP_FORLOOP */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)          /* OP_FORPREP */
- ,opmode(1, 0, OpArgN, OpArgU, iABC)           /* OP_TFORLOOP */
- ,opmode(0, 0, OpArgU, OpArgU, iABC)           /* OP_SETLIST */
- ,opmode(0, 0, OpArgN, OpArgN, iABC)           /* OP_CLOSE */
- ,opmode(0, 1, OpArgU, OpArgN, iABx)           /* OP_CLOSURE */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)           /* OP_VARARG */
-};

diff --git a/source3/lua-5.1.4/src/lopcodes.h b/source3/lua-5.1.4/src/lopcodes.h
deleted file mode 100644 (file)
index b4b86cf..0000000
--- a/source3/lua-5.1.4/src/lopcodes.h
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
-** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $
-** Opcodes for Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lopcodes_h
-#define lopcodes_h
-
-#include "llimits.h"
-
-
-/*===========================================================================
-  We assume that instructions are unsigned numbers.
-  All instructions have an opcode in the first 6 bits.
-  Instructions can have the following fields:
-       `A' : 8 bits
-       `B' : 9 bits
-       `C' : 9 bits
-       `Bx' : 18 bits (`B' and `C' together)
-       `sBx' : signed Bx
-
-  A signed argument is represented in excess K; that is, the number
-  value is the unsigned value minus K. K is exactly the maximum value
-  for that argument (so that -max is represented by 0, and +max is
-  represented by 2*max), which is half the maximum for the corresponding
-  unsigned argument.
-===========================================================================*/
-
-
-enum OpMode {iABC, iABx, iAsBx};  /* basic instruction format */
-
-
-/*
-** size and position of opcode arguments.
-*/
-#define SIZE_C         9
-#define SIZE_B         9
-#define SIZE_Bx                (SIZE_C + SIZE_B)
-#define SIZE_A         8
-
-#define SIZE_OP                6
-
-#define POS_OP         0
-#define POS_A          (POS_OP + SIZE_OP)
-#define POS_C          (POS_A + SIZE_A)
-#define POS_B          (POS_C + SIZE_C)
-#define POS_Bx         POS_C
-
-
-/*
-** limits for opcode arguments.
-** we use (signed) int to manipulate most arguments,
-** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
-*/
-#if SIZE_Bx < LUAI_BITSINT-1
-#define MAXARG_Bx        ((1<<SIZE_Bx)-1)
-#define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
-#else
-#define MAXARG_Bx        MAX_INT
-#define MAXARG_sBx        MAX_INT
-#endif
-
-
-#define MAXARG_A        ((1<<SIZE_A)-1)
-#define MAXARG_B        ((1<<SIZE_B)-1)
-#define MAXARG_C        ((1<<SIZE_C)-1)
-
-
-/* creates a mask with `n' 1 bits at position `p' */
-#define MASK1(n,p)     ((~((~(Instruction)0)<<n))<<p)
-
-/* creates a mask with `n' 0 bits at position `p' */
-#define MASK0(n,p)     (~MASK1(n,p))
-
-/*
-** the following macros help to manipulate instructions
-*/
-
-#define GET_OPCODE(i)  (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
-#define SET_OPCODE(i,o)        ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
-               ((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
-
-#define GETARG_A(i)    (cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
-#define SETARG_A(i,u)  ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
-               ((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
-
-#define GETARG_B(i)    (cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
-#define SETARG_B(i,b)  ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
-               ((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
-
-#define GETARG_C(i)    (cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
-#define SETARG_C(i,b)  ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
-               ((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
-
-#define GETARG_Bx(i)   (cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
-#define SETARG_Bx(i,b) ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
-               ((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
-
-#define GETARG_sBx(i)  (GETARG_Bx(i)-MAXARG_sBx)
-#define SETARG_sBx(i,b)        SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
-
-
-#define CREATE_ABC(o,a,b,c)    ((cast(Instruction, o)<<POS_OP) \
-                       | (cast(Instruction, a)<<POS_A) \
-                       | (cast(Instruction, b)<<POS_B) \
-                       | (cast(Instruction, c)<<POS_C))
-
-#define CREATE_ABx(o,a,bc)     ((cast(Instruction, o)<<POS_OP) \
-                       | (cast(Instruction, a)<<POS_A) \
-                       | (cast(Instruction, bc)<<POS_Bx))
-
-
-/*
-** Macros to operate RK indices
-*/
-
-/* this bit 1 means constant (0 means register) */
-#define BITRK          (1 << (SIZE_B - 1))
-
-/* test whether value is a constant */
-#define ISK(x)         ((x) & BITRK)
-
-/* gets the index of the constant */
-#define INDEXK(r)      ((int)(r) & ~BITRK)
-
-#define MAXINDEXRK     (BITRK - 1)
-
-/* code a constant index as a RK value */
-#define RKASK(x)       ((x) | BITRK)
-
-
-/*
-** invalid register that fits in 8 bits
-*/
-#define NO_REG         MAXARG_A
-
-
-/*
-** R(x) - register
-** Kst(x) - constant (in constant table)
-** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
-*/
-
-
-/*
-** grep "ORDER OP" if you change these enums
-*/
-
-typedef enum {
-/*----------------------------------------------------------------------
-name           args    description
-------------------------------------------------------------------------*/
-OP_MOVE,/*     A B     R(A) := R(B)                                    */
-OP_LOADK,/*    A Bx    R(A) := Kst(Bx)                                 */
-OP_LOADBOOL,/* A B C   R(A) := (Bool)B; if (C) pc++                    */
-OP_LOADNIL,/*  A B     R(A) := ... := R(B) := nil                      */
-OP_GETUPVAL,/* A B     R(A) := UpValue[B]                              */
-
-OP_GETGLOBAL,/*        A Bx    R(A) := Gbl[Kst(Bx)]                            */
-OP_GETTABLE,/* A B C   R(A) := R(B)[RK(C)]                             */
-
-OP_SETGLOBAL,/*        A Bx    Gbl[Kst(Bx)] := R(A)                            */
-OP_SETUPVAL,/* A B     UpValue[B] := R(A)                              */
-OP_SETTABLE,/* A B C   R(A)[RK(B)] := RK(C)                            */
-
-OP_NEWTABLE,/* A B C   R(A) := {} (size = B,C)                         */
-
-OP_SELF,/*     A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]             */
-
-OP_ADD,/*      A B C   R(A) := RK(B) + RK(C)                           */
-OP_SUB,/*      A B C   R(A) := RK(B) - RK(C)                           */
-OP_MUL,/*      A B C   R(A) := RK(B) * RK(C)                           */
-OP_DIV,/*      A B C   R(A) := RK(B) / RK(C)                           */
-OP_MOD,/*      A B C   R(A) := RK(B) % RK(C)                           */
-OP_POW,/*      A B C   R(A) := RK(B) ^ RK(C)                           */
-OP_UNM,/*      A B     R(A) := -R(B)                                   */
-OP_NOT,/*      A B     R(A) := not R(B)                                */
-OP_LEN,/*      A B     R(A) := length of R(B)                          */
-
-OP_CONCAT,/*   A B C   R(A) := R(B).. ... ..R(C)                       */
-
-OP_JMP,/*      sBx     pc+=sBx                                 */
-
-OP_EQ,/*       A B C   if ((RK(B) == RK(C)) ~= A) then pc++            */
-OP_LT,/*       A B C   if ((RK(B) <  RK(C)) ~= A) then pc++            */
-OP_LE,/*       A B C   if ((RK(B) <= RK(C)) ~= A) then pc++            */
-
-OP_TEST,/*     A C     if not (R(A) <=> C) then pc++                   */
-OP_TESTSET,/*  A B C   if (R(B) <=> C) then R(A) := R(B) else pc++     */
-
-OP_CALL,/*     A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
-OP_TAILCALL,/* A B C   return R(A)(R(A+1), ... ,R(A+B-1))              */
-OP_RETURN,/*   A B     return R(A), ... ,R(A+B-2)      (see note)      */
-
-OP_FORLOOP,/*  A sBx   R(A)+=R(A+2);
-                       if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
-OP_FORPREP,/*  A sBx   R(A)-=R(A+2); pc+=sBx                           */
-
-OP_TFORLOOP,/* A C     R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
-                        if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++  */
-OP_SETLIST,/*  A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B        */
-
-OP_CLOSE,/*    A       close all variables in the stack up to (>=) R(A)*/
-OP_CLOSURE,/*  A Bx    R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))  */
-
-OP_VARARG/*    A B     R(A), R(A+1), ..., R(A+B-1) = vararg            */
-} OpCode;
-
-
-#define NUM_OPCODES    (cast(int, OP_VARARG) + 1)
-
-
-
-/*===========================================================================
-  Notes:
-  (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
-      and can be 0: OP_CALL then sets `top' to last_result+1, so
-      next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
-
-  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
-      set top (like in OP_CALL with C == 0).
-
-  (*) In OP_RETURN, if (B == 0) then return up to `top'
-
-  (*) In OP_SETLIST, if (B == 0) then B = `top';
-      if (C == 0) then next `instruction' is real C
-
-  (*) For comparisons, A specifies what condition the test should accept
-      (true or false).
-
-  (*) All `skips' (pc++) assume that next instruction is a jump
-===========================================================================*/
-
-
-/*
-** masks for instruction properties. The format is:
-** bits 0-1: op mode
-** bits 2-3: C arg mode
-** bits 4-5: B arg mode
-** bit 6: instruction set register A
-** bit 7: operator is a test
-*/
-
-enum OpArgMask {
-  OpArgN,  /* argument is not used */
-  OpArgU,  /* argument is used */
-  OpArgR,  /* argument is a register or a jump offset */
-  OpArgK   /* argument is a constant or register/constant */
-};
-
-LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
-
-#define getOpMode(m)   (cast(enum OpMode, luaP_opmodes[m] & 3))
-#define getBMode(m)    (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
-#define getCMode(m)    (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
-#define testAMode(m)   (luaP_opmodes[m] & (1 << 6))
-#define testTMode(m)   (luaP_opmodes[m] & (1 << 7))
-
-
-LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
-
-
-/* number of list items to accumulate before a SETLIST instruction */
-#define LFIELDS_PER_FLUSH      50
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/loslib.c b/source3/lua-5.1.4/src/loslib.c
deleted file mode 100644 (file)
index 2ff4531..0000000
--- a/source3/lua-5.1.4/src/loslib.c
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
-** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $
-** Standard Operating System library
-** See Copyright Notice in lua.h
-*/
-
-
-#include <errno.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#define loslib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-static int os_pushresult (lua_State *L, int i, const char *filename) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (i) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    lua_pushfstring(L, "%s: %s", filename, strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
-
-
-static int os_execute (lua_State *L) {
-  lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
-  return 1;
-}
-
-
-static int os_remove (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  return os_pushresult(L, remove(filename) == 0, filename);
-}
-
-
-static int os_rename (lua_State *L) {
-  const char *fromname = luaL_checkstring(L, 1);
-  const char *toname = luaL_checkstring(L, 2);
-  return os_pushresult(L, rename(fromname, toname) == 0, fromname);
-}
-
-
-static int os_tmpname (lua_State *L) {
-  char buff[LUA_TMPNAMBUFSIZE];
-  int err;
-  lua_tmpnam(buff, err);
-  if (err)
-    return luaL_error(L, "unable to generate a unique filename");
-  lua_pushstring(L, buff);
-  return 1;
-}
-
-
-static int os_getenv (lua_State *L) {
-  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
-  return 1;
-}
-
-
-static int os_clock (lua_State *L) {
-  lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
-  return 1;
-}
-
-
-/*
-** {======================================================
-** Time/Date operations
-** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
-**   wday=%w+1, yday=%j, isdst=? }
-** =======================================================
-*/
-
-static void setfield (lua_State *L, const char *key, int value) {
-  lua_pushinteger(L, value);
-  lua_setfield(L, -2, key);
-}
-
-static void setboolfield (lua_State *L, const char *key, int value) {
-  if (value < 0)  /* undefined? */
-    return;  /* does not set field */
-  lua_pushboolean(L, value);
-  lua_setfield(L, -2, key);
-}
-
-static int getboolfield (lua_State *L, const char *key) {
-  int res;
-  lua_getfield(L, -1, key);
-  res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
-  lua_pop(L, 1);
-  return res;
-}
-
-
-static int getfield (lua_State *L, const char *key, int d) {
-  int res;
-  lua_getfield(L, -1, key);
-  if (lua_isnumber(L, -1))
-    res = (int)lua_tointeger(L, -1);
-  else {
-    if (d < 0)
-      return luaL_error(L, "field " LUA_QS " missing in date table", key);
-    res = d;
-  }
-  lua_pop(L, 1);
-  return res;
-}
-
-
-static int os_date (lua_State *L) {
-  const char *s = luaL_optstring(L, 1, "%c");
-  time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
-  struct tm *stm;
-  if (*s == '!') {  /* UTC? */
-    stm = gmtime(&t);
-    s++;  /* skip `!' */
-  }
-  else
-    stm = localtime(&t);
-  if (stm == NULL)  /* invalid date? */
-    lua_pushnil(L);
-  else if (strcmp(s, "*t") == 0) {
-    lua_createtable(L, 0, 9);  /* 9 = number of fields */
-    setfield(L, "sec", stm->tm_sec);
-    setfield(L, "min", stm->tm_min);
-    setfield(L, "hour", stm->tm_hour);
-    setfield(L, "day", stm->tm_mday);
-    setfield(L, "month", stm->tm_mon+1);
-    setfield(L, "year", stm->tm_year+1900);
-    setfield(L, "wday", stm->tm_wday+1);
-    setfield(L, "yday", stm->tm_yday+1);
-    setboolfield(L, "isdst", stm->tm_isdst);
-  }
-  else {
-    char cc[3];
-    luaL_Buffer b;
-    cc[0] = '%'; cc[2] = '\0';
-    luaL_buffinit(L, &b);
-    for (; *s; s++) {
-      if (*s != '%' || *(s + 1) == '\0')  /* no conversion specifier? */
-        luaL_addchar(&b, *s);
-      else {
-        size_t reslen;
-        char buff[200];  /* should be big enough for any conversion result */
-        cc[1] = *(++s);
-        reslen = strftime(buff, sizeof(buff), cc, stm);
-        luaL_addlstring(&b, buff, reslen);
-      }
-    }
-    luaL_pushresult(&b);
-  }
-  return 1;
-}
-
-
-static int os_time (lua_State *L) {
-  time_t t;
-  if (lua_isnoneornil(L, 1))  /* called without args? */
-    t = time(NULL);  /* get current time */
-  else {
-    struct tm ts;
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_settop(L, 1);  /* make sure table is at the top */
-    ts.tm_sec = getfield(L, "sec", 0);
-    ts.tm_min = getfield(L, "min", 0);
-    ts.tm_hour = getfield(L, "hour", 12);
-    ts.tm_mday = getfield(L, "day", -1);
-    ts.tm_mon = getfield(L, "month", -1) - 1;
-    ts.tm_year = getfield(L, "year", -1) - 1900;
-    ts.tm_isdst = getboolfield(L, "isdst");
-    t = mktime(&ts);
-  }
-  if (t == (time_t)(-1))
-    lua_pushnil(L);
-  else
-    lua_pushnumber(L, (lua_Number)t);
-  return 1;
-}
-
-
-static int os_difftime (lua_State *L) {
-  lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
-                             (time_t)(luaL_optnumber(L, 2, 0))));
-  return 1;
-}
-
-/* }====================================================== */
-
-
-static int os_setlocale (lua_State *L) {
-  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
-                      LC_NUMERIC, LC_TIME};
-  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
-     "numeric", "time", NULL};
-  const char *l = luaL_optstring(L, 1, NULL);
-  int op = luaL_checkoption(L, 2, "all", catnames);
-  lua_pushstring(L, setlocale(cat[op], l));
-  return 1;
-}
-
-
-static int os_exit (lua_State *L) {
-  exit(luaL_optint(L, 1, EXIT_SUCCESS));
-}
-
-static const luaL_Reg syslib[] = {
-  {"clock",     os_clock},
-  {"date",      os_date},
-  {"difftime",  os_difftime},
-  {"execute",   os_execute},
-  {"exit",      os_exit},
-  {"getenv",    os_getenv},
-  {"remove",    os_remove},
-  {"rename",    os_rename},
-  {"setlocale", os_setlocale},
-  {"time",      os_time},
-  {"tmpname",   os_tmpname},
-  {NULL, NULL}
-};
-
-/* }====================================================== */
-
-
-
-LUALIB_API int luaopen_os (lua_State *L) {
-  luaL_register(L, LUA_OSLIBNAME, syslib);
-  return 1;
-}

diff --git a/source3/lua-5.1.4/src/lparser.c b/source3/lua-5.1.4/src/lparser.c
deleted file mode 100644 (file)
index 1e2a9a8..0000000
--- a/source3/lua-5.1.4/src/lparser.c
+++ /dev/null
@@ -1,1339 +0,0 @@
-/*
-** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define lparser_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-
-
-
-#define hasmultret(k)          ((k) == VCALL || (k) == VVARARG)
-
-#define getlocvar(fs, i)       ((fs)->f->locvars[(fs)->actvar[i]])
-
-#define luaY_checklimit(fs,v,l,m)      if ((v)>(l)) errorlimit(fs,l,m)
-
-
-/*
-** nodes for block list (list of active blocks)
-*/
-typedef struct BlockCnt {
-  struct BlockCnt *previous;  /* chain */
-  int breaklist;  /* list of jumps out of this loop */
-  lu_byte nactvar;  /* # active locals outside the breakable structure */
-  lu_byte upval;  /* true if some variable in the block is an upvalue */
-  lu_byte isbreakable;  /* true if `block' is a loop */
-} BlockCnt;
-
-
-
-/*
-** prototypes for recursive non-terminal functions
-*/
-static void chunk (LexState *ls);
-static void expr (LexState *ls, expdesc *v);
-
-
-static void anchor_token (LexState *ls) {
-  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
-    TString *ts = ls->t.seminfo.ts;
-    luaX_newstring(ls, getstr(ts), ts->tsv.len);
-  }
-}
-
-
-static void error_expected (LexState *ls, int token) {
-  luaX_syntaxerror(ls,
-      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
-}
-
-
-static void errorlimit (FuncState *fs, int limit, const char *what) {
-  const char *msg = (fs->f->linedefined == 0) ?
-    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
-    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
-                            fs->f->linedefined, limit, what);
-  luaX_lexerror(fs->ls, msg, 0);
-}
-
-
-static int testnext (LexState *ls, int c) {
-  if (ls->t.token == c) {
-    luaX_next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-static void check (LexState *ls, int c) {
-  if (ls->t.token != c)
-    error_expected(ls, c);
-}
-
-static void checknext (LexState *ls, int c) {
-  check(ls, c);
-  luaX_next(ls);
-}
-
-
-#define check_condition(ls,c,msg)      { if (!(c)) luaX_syntaxerror(ls, msg); }
-
-
-
-static void check_match (LexState *ls, int what, int who, int where) {
-  if (!testnext(ls, what)) {
-    if (where == ls->linenumber)
-      error_expected(ls, what);
-    else {
-      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
-             LUA_QS " expected (to close " LUA_QS " at line %d)",
-              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
-    }
-  }
-}
-
-
-static TString *str_checkname (LexState *ls) {
-  TString *ts;
-  check(ls, TK_NAME);
-  ts = ls->t.seminfo.ts;
-  luaX_next(ls);
-  return ts;
-}
-
-
-static void init_exp (expdesc *e, expkind k, int i) {
-  e->f = e->t = NO_JUMP;
-  e->k = k;
-  e->u.s.info = i;
-}
-
-
-static void codestring (LexState *ls, expdesc *e, TString *s) {
-  init_exp(e, VK, luaK_stringK(ls->fs, s));
-}
-
-
-static void checkname(LexState *ls, expdesc *e) {
-  codestring(ls, e, str_checkname(ls));
-}
-
-
-static int registerlocalvar (LexState *ls, TString *varname) {
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int oldsize = f->sizelocvars;
-  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
-                  LocVar, SHRT_MAX, "too many local variables");
-  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
-  f->locvars[fs->nlocvars].varname = varname;
-  luaC_objbarrier(ls->L, f, varname);
-  return fs->nlocvars++;
-}
-
-
-#define new_localvarliteral(ls,v,n) \
-  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
-
-
-static void new_localvar (LexState *ls, TString *name, int n) {
-  FuncState *fs = ls->fs;
-  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
-  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
-}
-
-
-static void adjustlocalvars (LexState *ls, int nvars) {
-  FuncState *fs = ls->fs;
-  fs->nactvar = cast_byte(fs->nactvar + nvars);
-  for (; nvars; nvars--) {
-    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
-  }
-}
-
-
-static void removevars (LexState *ls, int tolevel) {
-  FuncState *fs = ls->fs;
-  while (fs->nactvar > tolevel)
-    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
-}
-
-
-static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
-  int i;
-  Proto *f = fs->f;
-  int oldsize = f->sizeupvalues;
-  for (i=0; i<f->nups; i++) {
-    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
-      lua_assert(f->upvalues[i] == name);
-      return i;
-    }
-  }
-  /* new one */
-  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
-  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
-                  TString *, MAX_INT, "");
-  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
-  f->upvalues[f->nups] = name;
-  luaC_objbarrier(fs->L, f, name);
-  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
-  fs->upvalues[f->nups].k = cast_byte(v->k);
-  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
-  return f->nups++;
-}
-
-
-static int searchvar (FuncState *fs, TString *n) {
-  int i;
-  for (i=fs->nactvar-1; i >= 0; i--) {
-    if (n == getlocvar(fs, i).varname)
-      return i;
-  }
-  return -1;  /* not found */
-}
-
-
-static void markupval (FuncState *fs, int level) {
-  BlockCnt *bl = fs->bl;
-  while (bl && bl->nactvar > level) bl = bl->previous;
-  if (bl) bl->upval = 1;
-}
-
-
-static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
-  if (fs == NULL) {  /* no more levels? */
-    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
-    return VGLOBAL;
-  }
-  else {
-    int v = searchvar(fs, n);  /* look up at current level */
-    if (v >= 0) {
-      init_exp(var, VLOCAL, v);
-      if (!base)
-        markupval(fs, v);  /* local will be used as an upval */
-      return VLOCAL;
-    }
-    else {  /* not found at current level; try upper one */
-      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
-        return VGLOBAL;
-      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
-      var->k = VUPVAL;  /* upvalue in this level */
-      return VUPVAL;
-    }
-  }
-}
-
-
-static void singlevar (LexState *ls, expdesc *var) {
-  TString *varname = str_checkname(ls);
-  FuncState *fs = ls->fs;
-  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
-    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
-}
-
-
-static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
-  FuncState *fs = ls->fs;
-  int extra = nvars - nexps;
-  if (hasmultret(e->k)) {
-    extra++;  /* includes call itself */
-    if (extra < 0) extra = 0;
-    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
-    if (extra > 1) luaK_reserveregs(fs, extra-1);
-  }
-  else {
-    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
-    if (extra > 0) {
-      int reg = fs->freereg;
-      luaK_reserveregs(fs, extra);
-      luaK_nil(fs, reg, extra);
-    }
-  }
-}
-
-
-static void enterlevel (LexState *ls) {
-  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
-       luaX_lexerror(ls, "chunk has too many syntax levels", 0);
-}
-
-
-#define leavelevel(ls) ((ls)->L->nCcalls--)
-
-
-static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
-  bl->breaklist = NO_JUMP;
-  bl->isbreakable = isbreakable;
-  bl->nactvar = fs->nactvar;
-  bl->upval = 0;
-  bl->previous = fs->bl;
-  fs->bl = bl;
-  lua_assert(fs->freereg == fs->nactvar);
-}
-
-
-static void leaveblock (FuncState *fs) {
-  BlockCnt *bl = fs->bl;
-  fs->bl = bl->previous;
-  removevars(fs->ls, bl->nactvar);
-  if (bl->upval)
-    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
-  /* a block either controls scope or breaks (never both) */
-  lua_assert(!bl->isbreakable || !bl->upval);
-  lua_assert(bl->nactvar == fs->nactvar);
-  fs->freereg = fs->nactvar;  /* free registers */
-  luaK_patchtohere(fs, bl->breaklist);
-}
-
-
-static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int oldsize = f->sizep;
-  int i;
-  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
-                  MAXARG_Bx, "constant table overflow");
-  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
-  f->p[fs->np++] = func->f;
-  luaC_objbarrier(ls->L, f, func->f);
-  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
-  for (i=0; i<func->f->nups; i++) {
-    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
-    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
-  }
-}
-
-
-static void open_func (LexState *ls, FuncState *fs) {
-  lua_State *L = ls->L;
-  Proto *f = luaF_newproto(L);
-  fs->f = f;
-  fs->prev = ls->fs;  /* linked list of funcstates */
-  fs->ls = ls;
-  fs->L = L;
-  ls->fs = fs;
-  fs->pc = 0;
-  fs->lasttarget = -1;
-  fs->jpc = NO_JUMP;
-  fs->freereg = 0;
-  fs->nk = 0;
-  fs->np = 0;
-  fs->nlocvars = 0;
-  fs->nactvar = 0;
-  fs->bl = NULL;
-  f->source = ls->source;
-  f->maxstacksize = 2;  /* registers 0/1 are always valid */
-  fs->h = luaH_new(L, 0, 0);
-  /* anchor table of constants and prototype (to avoid being collected) */
-  sethvalue2s(L, L->top, fs->h);
-  incr_top(L);
-  setptvalue2s(L, L->top, f);
-  incr_top(L);
-}
-
-
-static void close_func (LexState *ls) {
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  removevars(ls, 0);
-  luaK_ret(fs, 0, 0);  /* final return */
-  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
-  f->sizecode = fs->pc;
-  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
-  f->sizelineinfo = fs->pc;
-  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
-  f->sizek = fs->nk;
-  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
-  f->sizep = fs->np;
-  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
-  f->sizelocvars = fs->nlocvars;
-  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
-  f->sizeupvalues = f->nups;
-  lua_assert(luaG_checkcode(f));
-  lua_assert(fs->bl == NULL);
-  ls->fs = fs->prev;
-  L->top -= 2;  /* remove table and prototype from the stack */
-  /* last token read was anchored in defunct function; must reanchor it */
-  if (fs) anchor_token(ls);
-}
-
-
-Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
-  struct LexState lexstate;
-  struct FuncState funcstate;
-  lexstate.buff = buff;
-  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
-  open_func(&lexstate, &funcstate);
-  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
-  luaX_next(&lexstate);  /* read first token */
-  chunk(&lexstate);
-  check(&lexstate, TK_EOS);
-  close_func(&lexstate);
-  lua_assert(funcstate.prev == NULL);
-  lua_assert(funcstate.f->nups == 0);
-  lua_assert(lexstate.fs == NULL);
-  return funcstate.f;
-}
-
-
-
-/*============================================================*/
-/* GRAMMAR RULES */
-/*============================================================*/
-
-
-static void field (LexState *ls, expdesc *v) {
-  /* field -> ['.' | ':'] NAME */
-  FuncState *fs = ls->fs;
-  expdesc key;
-  luaK_exp2anyreg(fs, v);
-  luaX_next(ls);  /* skip the dot or colon */
-  checkname(ls, &key);
-  luaK_indexed(fs, v, &key);
-}
-
-
-static void yindex (LexState *ls, expdesc *v) {
-  /* index -> '[' expr ']' */
-  luaX_next(ls);  /* skip the '[' */
-  expr(ls, v);
-  luaK_exp2val(ls->fs, v);
-  checknext(ls, ']');
-}
-
-
-/*
-** {======================================================================
-** Rules for Constructors
-** =======================================================================
-*/
-
-
-struct ConsControl {
-  expdesc v;  /* last list item read */
-  expdesc *t;  /* table descriptor */
-  int nh;  /* total number of `record' elements */
-  int na;  /* total number of array elements */
-  int tostore;  /* number of array elements pending to be stored */
-};
-
-
-static void recfield (LexState *ls, struct ConsControl *cc) {
-  /* recfield -> (NAME | `['exp1`]') = exp1 */
-  FuncState *fs = ls->fs;
-  int reg = ls->fs->freereg;
-  expdesc key, val;
-  int rkkey;
-  if (ls->t.token == TK_NAME) {
-    luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
-    checkname(ls, &key);
-  }
-  else  /* ls->t.token == '[' */
-    yindex(ls, &key);
-  cc->nh++;
-  checknext(ls, '=');
-  rkkey = luaK_exp2RK(fs, &key);
-  expr(ls, &val);
-  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
-  fs->freereg = reg;  /* free registers */
-}
-
-
-static void closelistfield (FuncState *fs, struct ConsControl *cc) {
-  if (cc->v.k == VVOID) return;  /* there is no list item */
-  luaK_exp2nextreg(fs, &cc->v);
-  cc->v.k = VVOID;
-  if (cc->tostore == LFIELDS_PER_FLUSH) {
-    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
-    cc->tostore = 0;  /* no more items pending */
-  }
-}
-
-
-static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
-  if (cc->tostore == 0) return;
-  if (hasmultret(cc->v.k)) {
-    luaK_setmultret(fs, &cc->v);
-    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
-    cc->na--;  /* do not count last expression (unknown number of elements) */
-  }
-  else {
-    if (cc->v.k != VVOID)
-      luaK_exp2nextreg(fs, &cc->v);
-    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
-  }
-}
-
-
-static void listfield (LexState *ls, struct ConsControl *cc) {
-  expr(ls, &cc->v);
-  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
-  cc->na++;
-  cc->tostore++;
-}
-
-
-static void constructor (LexState *ls, expdesc *t) {
-  /* constructor -> ?? */
-  FuncState *fs = ls->fs;
-  int line = ls->linenumber;
-  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
-  struct ConsControl cc;
-  cc.na = cc.nh = cc.tostore = 0;
-  cc.t = t;
-  init_exp(t, VRELOCABLE, pc);
-  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
-  luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
-  checknext(ls, '{');
-  do {
-    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
-    if (ls->t.token == '}') break;
-    closelistfield(fs, &cc);
-    switch(ls->t.token) {
-      case TK_NAME: {  /* may be listfields or recfields */
-        luaX_lookahead(ls);
-        if (ls->lookahead.token != '=')  /* expression? */
-          listfield(ls, &cc);
-        else
-          recfield(ls, &cc);
-        break;
-      }
-      case '[': {  /* constructor_item -> recfield */
-        recfield(ls, &cc);
-        break;
-      }
-      default: {  /* constructor_part -> listfield */
-        listfield(ls, &cc);
-        break;
-      }
-    }
-  } while (testnext(ls, ',') || testnext(ls, ';'));
-  check_match(ls, '}', '{', line);
-  lastlistfield(fs, &cc);
-  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
-  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
-}
-
-/* }====================================================================== */
-
-
-
-static void parlist (LexState *ls) {
-  /* parlist -> [ param { `,' param } ] */
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int nparams = 0;
-  f->is_vararg = 0;
-  if (ls->t.token != ')') {  /* is `parlist' not empty? */
-    do {
-      switch (ls->t.token) {
-        case TK_NAME: {  /* param -> NAME */
-          new_localvar(ls, str_checkname(ls), nparams++);
-          break;
-        }
-        case TK_DOTS: {  /* param -> `...' */
-          luaX_next(ls);
-#if defined(LUA_COMPAT_VARARG)
-          /* use `arg' as default name */
-          new_localvarliteral(ls, "arg", nparams++);
-          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
-#endif
-          f->is_vararg |= VARARG_ISVARARG;
-          break;
-        }
-        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
-      }
-    } while (!f->is_vararg && testnext(ls, ','));
-  }
-  adjustlocalvars(ls, nparams);
-  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
-  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
-}
-
-
-static void body (LexState *ls, expdesc *e, int needself, int line) {
-  /* body ->  `(' parlist `)' chunk END */
-  FuncState new_fs;
-  open_func(ls, &new_fs);
-  new_fs.f->linedefined = line;
-  checknext(ls, '(');
-  if (needself) {
-    new_localvarliteral(ls, "self", 0);
-    adjustlocalvars(ls, 1);
-  }
-  parlist(ls);
-  checknext(ls, ')');
-  chunk(ls);
-  new_fs.f->lastlinedefined = ls->linenumber;
-  check_match(ls, TK_END, TK_FUNCTION, line);
-  close_func(ls);
-  pushclosure(ls, &new_fs, e);
-}
-
-
-static int explist1 (LexState *ls, expdesc *v) {
-  /* explist1 -> expr { `,' expr } */
-  int n = 1;  /* at least one expression */
-  expr(ls, v);
-  while (testnext(ls, ',')) {
-    luaK_exp2nextreg(ls->fs, v);
-    expr(ls, v);
-    n++;
-  }
-  return n;
-}
-
-
-static void funcargs (LexState *ls, expdesc *f) {
-  FuncState *fs = ls->fs;
-  expdesc args;
-  int base, nparams;
-  int line = ls->linenumber;
-  switch (ls->t.token) {
-    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
-      if (line != ls->lastline)
-        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
-      luaX_next(ls);
-      if (ls->t.token == ')')  /* arg list is empty? */
-        args.k = VVOID;
-      else {
-        explist1(ls, &args);
-        luaK_setmultret(fs, &args);
-      }
-      check_match(ls, ')', '(', line);
-      break;
-    }
-    case '{': {  /* funcargs -> constructor */
-      constructor(ls, &args);
-      break;
-    }
-    case TK_STRING: {  /* funcargs -> STRING */
-      codestring(ls, &args, ls->t.seminfo.ts);
-      luaX_next(ls);  /* must use `seminfo' before `next' */
-      break;
-    }
-    default: {
-      luaX_syntaxerror(ls, "function arguments expected");
-      return;
-    }
-  }
-  lua_assert(f->k == VNONRELOC);
-  base = f->u.s.info;  /* base register for call */
-  if (hasmultret(args.k))
-    nparams = LUA_MULTRET;  /* open call */
-  else {
-    if (args.k != VVOID)
-      luaK_exp2nextreg(fs, &args);  /* close last argument */
-    nparams = fs->freereg - (base+1);
-  }
-  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
-  luaK_fixline(fs, line);
-  fs->freereg = base+1;  /* call remove function and arguments and leaves
-                            (unless changed) one result */
-}
-
-
-
-
-/*
-** {======================================================================
-** Expression parsing
-** =======================================================================
-*/
-
-
-static void prefixexp (LexState *ls, expdesc *v) {
-  /* prefixexp -> NAME | '(' expr ')' */
-  switch (ls->t.token) {
-    case '(': {
-      int line = ls->linenumber;
-      luaX_next(ls);
-      expr(ls, v);
-      check_match(ls, ')', '(', line);
-      luaK_dischargevars(ls->fs, v);
-      return;
-    }
-    case TK_NAME: {
-      singlevar(ls, v);
-      return;
-    }
-    default: {
-      luaX_syntaxerror(ls, "unexpected symbol");
-      return;
-    }
-  }
-}
-
-
-static void primaryexp (LexState *ls, expdesc *v) {
-  /* primaryexp ->
-        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
-  FuncState *fs = ls->fs;
-  prefixexp(ls, v);
-  for (;;) {
-    switch (ls->t.token) {
-      case '.': {  /* field */
-        field(ls, v);
-        break;
-      }
-      case '[': {  /* `[' exp1 `]' */
-        expdesc key;
-        luaK_exp2anyreg(fs, v);
-        yindex(ls, &key);
-        luaK_indexed(fs, v, &key);
-        break;
-      }
-      case ':': {  /* `:' NAME funcargs */
-        expdesc key;
-        luaX_next(ls);
-        checkname(ls, &key);
-        luaK_self(fs, v, &key);
-        funcargs(ls, v);
-        break;
-      }
-      case '(': case TK_STRING: case '{': {  /* funcargs */
-        luaK_exp2nextreg(fs, v);
-        funcargs(ls, v);
-        break;
-      }
-      default: return;
-    }
-  }
-}
-
-
-static void simpleexp (LexState *ls, expdesc *v) {
-  /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
-                  constructor | FUNCTION body | primaryexp */
-  switch (ls->t.token) {
-    case TK_NUMBER: {
-      init_exp(v, VKNUM, 0);
-      v->u.nval = ls->t.seminfo.r;
-      break;
-    }
-    case TK_STRING: {
-      codestring(ls, v, ls->t.seminfo.ts);
-      break;
-    }
-    case TK_NIL: {
-      init_exp(v, VNIL, 0);
-      break;
-    }
-    case TK_TRUE: {
-      init_exp(v, VTRUE, 0);
-      break;
-    }
-    case TK_FALSE: {
-      init_exp(v, VFALSE, 0);
-      break;
-    }
-    case TK_DOTS: {  /* vararg */
-      FuncState *fs = ls->fs;
-      check_condition(ls, fs->f->is_vararg,
-                      "cannot use " LUA_QL("...") " outside a vararg function");
-      fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
-      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
-      break;
-    }
-    case '{': {  /* constructor */
-      constructor(ls, v);
-      return;
-    }
-    case TK_FUNCTION: {
-      luaX_next(ls);
-      body(ls, v, 0, ls->linenumber);
-      return;
-    }
-    default: {
-      primaryexp(ls, v);
-      return;
-    }
-  }
-  luaX_next(ls);
-}
-
-
-static UnOpr getunopr (int op) {
-  switch (op) {
-    case TK_NOT: return OPR_NOT;
-    case '-': return OPR_MINUS;
-    case '#': return OPR_LEN;
-    default: return OPR_NOUNOPR;
-  }
-}
-
-
-static BinOpr getbinopr (int op) {
-  switch (op) {
-    case '+': return OPR_ADD;
-    case '-': return OPR_SUB;
-    case '*': return OPR_MUL;
-    case '/': return OPR_DIV;
-    case '%': return OPR_MOD;
-    case '^': return OPR_POW;
-    case TK_CONCAT: return OPR_CONCAT;
-    case TK_NE: return OPR_NE;
-    case TK_EQ: return OPR_EQ;
-    case '<': return OPR_LT;
-    case TK_LE: return OPR_LE;
-    case '>': return OPR_GT;
-    case TK_GE: return OPR_GE;
-    case TK_AND: return OPR_AND;
-    case TK_OR: return OPR_OR;
-    default: return OPR_NOBINOPR;
-  }
-}
-
-
-static const struct {
-  lu_byte left;  /* left priority for each binary operator */
-  lu_byte right; /* right priority */
-} priority[] = {  /* ORDER OPR */
-   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
-   {10, 9}, {5, 4},                 /* power and concat (right associative) */
-   {3, 3}, {3, 3},                  /* equality and inequality */
-   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
-   {2, 2}, {1, 1}                   /* logical (and/or) */
-};
-
-#define UNARY_PRIORITY 8  /* priority for unary operators */
-
-
-/*
-** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
-** where `binop' is any binary operator with a priority higher than `limit'
-*/
-static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
-  BinOpr op;
-  UnOpr uop;
-  enterlevel(ls);
-  uop = getunopr(ls->t.token);
-  if (uop != OPR_NOUNOPR) {
-    luaX_next(ls);
-    subexpr(ls, v, UNARY_PRIORITY);
-    luaK_prefix(ls->fs, uop, v);
-  }
-  else simpleexp(ls, v);
-  /* expand while operators have priorities higher than `limit' */
-  op = getbinopr(ls->t.token);
-  while (op != OPR_NOBINOPR && priority[op].left > limit) {
-    expdesc v2;
-    BinOpr nextop;
-    luaX_next(ls);
-    luaK_infix(ls->fs, op, v);
-    /* read sub-expression with higher priority */
-    nextop = subexpr(ls, &v2, priority[op].right);
-    luaK_posfix(ls->fs, op, v, &v2);
-    op = nextop;
-  }
-  leavelevel(ls);
-  return op;  /* return first untreated operator */
-}
-
-
-static void expr (LexState *ls, expdesc *v) {
-  subexpr(ls, v, 0);
-}
-
-/* }==================================================================== */
-
-
-
-/*
-** {======================================================================
-** Rules for Statements
-** =======================================================================
-*/
-
-
-static int block_follow (int token) {
-  switch (token) {
-    case TK_ELSE: case TK_ELSEIF: case TK_END:
-    case TK_UNTIL: case TK_EOS:
-      return 1;
-    default: return 0;
-  }
-}
-
-
-static void block (LexState *ls) {
-  /* block -> chunk */
-  FuncState *fs = ls->fs;
-  BlockCnt bl;
-  enterblock(fs, &bl, 0);
-  chunk(ls);
-  lua_assert(bl.breaklist == NO_JUMP);
-  leaveblock(fs);
-}
-
-
-/*
-** structure to chain all variables in the left-hand side of an
-** assignment
-*/
-struct LHS_assign {
-  struct LHS_assign *prev;
-  expdesc v;  /* variable (global, local, upvalue, or indexed) */
-};
-
-
-/*
-** check whether, in an assignment to a local variable, the local variable
-** is needed in a previous assignment (to a table). If so, save original
-** local value in a safe place and use this safe copy in the previous
-** assignment.
-*/
-static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
-  FuncState *fs = ls->fs;
-  int extra = fs->freereg;  /* eventual position to save local variable */
-  int conflict = 0;
-  for (; lh; lh = lh->prev) {
-    if (lh->v.k == VINDEXED) {
-      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
-        conflict = 1;
-        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
-      }
-      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
-        conflict = 1;
-        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
-      }
-    }
-  }
-  if (conflict) {
-    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-
-static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
-  expdesc e;
-  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
-                      "syntax error");
-  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
-    struct LHS_assign nv;
-    nv.prev = lh;
-    primaryexp(ls, &nv.v);
-    if (nv.v.k == VLOCAL)
-      check_conflict(ls, lh, &nv.v);
-    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
-                    "variables in assignment");
-    assignment(ls, &nv, nvars+1);
-  }
-  else {  /* assignment -> `=' explist1 */
-    int nexps;
-    checknext(ls, '=');
-    nexps = explist1(ls, &e);
-    if (nexps != nvars) {
-      adjust_assign(ls, nvars, nexps, &e);
-      if (nexps > nvars)
-        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
-    }
-    else {
-      luaK_setoneret(ls->fs, &e);  /* close last expression */
-      luaK_storevar(ls->fs, &lh->v, &e);
-      return;  /* avoid default */
-    }
-  }
-  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
-  luaK_storevar(ls->fs, &lh->v, &e);
-}
-
-
-static int cond (LexState *ls) {
-  /* cond -> exp */
-  expdesc v;
-  expr(ls, &v);  /* read condition */
-  if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
-  luaK_goiftrue(ls->fs, &v);
-  return v.f;
-}
-
-
-static void breakstat (LexState *ls) {
-  FuncState *fs = ls->fs;
-  BlockCnt *bl = fs->bl;
-  int upval = 0;
-  while (bl && !bl->isbreakable) {
-    upval |= bl->upval;
-    bl = bl->previous;
-  }
-  if (!bl)
-    luaX_syntaxerror(ls, "no loop to break");
-  if (upval)
-    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
-  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
-}
-
-
-static void whilestat (LexState *ls, int line) {
-  /* whilestat -> WHILE cond DO block END */
-  FuncState *fs = ls->fs;
-  int whileinit;
-  int condexit;
-  BlockCnt bl;
-  luaX_next(ls);  /* skip WHILE */
-  whileinit = luaK_getlabel(fs);
-  condexit = cond(ls);
-  enterblock(fs, &bl, 1);
-  checknext(ls, TK_DO);
-  block(ls);
-  luaK_patchlist(fs, luaK_jump(fs), whileinit);
-  check_match(ls, TK_END, TK_WHILE, line);
-  leaveblock(fs);
-  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
-}
-
-
-static void repeatstat (LexState *ls, int line) {
-  /* repeatstat -> REPEAT block UNTIL cond */
-  int condexit;
-  FuncState *fs = ls->fs;
-  int repeat_init = luaK_getlabel(fs);
-  BlockCnt bl1, bl2;
-  enterblock(fs, &bl1, 1);  /* loop block */
-  enterblock(fs, &bl2, 0);  /* scope block */
-  luaX_next(ls);  /* skip REPEAT */
-  chunk(ls);
-  check_match(ls, TK_UNTIL, TK_REPEAT, line);
-  condexit = cond(ls);  /* read condition (inside scope block) */
-  if (!bl2.upval) {  /* no upvalues? */
-    leaveblock(fs);  /* finish scope */
-    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
-  }
-  else {  /* complete semantics when there are upvalues */
-    breakstat(ls);  /* if condition then break */
-    luaK_patchtohere(ls->fs, condexit);  /* else... */
-    leaveblock(fs);  /* finish scope... */
-    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
-  }
-  leaveblock(fs);  /* finish loop */
-}
-
-
-static int exp1 (LexState *ls) {
-  expdesc e;
-  int k;
-  expr(ls, &e);
-  k = e.k;
-  luaK_exp2nextreg(ls->fs, &e);
-  return k;
-}
-
-
-static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
-  /* forbody -> DO block */
-  BlockCnt bl;
-  FuncState *fs = ls->fs;
-  int prep, endfor;
-  adjustlocalvars(ls, 3);  /* control variables */
-  checknext(ls, TK_DO);
-  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
-  enterblock(fs, &bl, 0);  /* scope for declared variables */
-  adjustlocalvars(ls, nvars);
-  luaK_reserveregs(fs, nvars);
-  block(ls);
-  leaveblock(fs);  /* end of scope for declared variables */
-  luaK_patchtohere(fs, prep);
-  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
-                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
-  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
-  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
-}
-
-
-static void fornum (LexState *ls, TString *varname, int line) {
-  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
-  FuncState *fs = ls->fs;
-  int base = fs->freereg;
-  new_localvarliteral(ls, "(for index)", 0);
-  new_localvarliteral(ls, "(for limit)", 1);
-  new_localvarliteral(ls, "(for step)", 2);
-  new_localvar(ls, varname, 3);
-  checknext(ls, '=');
-  exp1(ls);  /* initial value */
-  checknext(ls, ',');
-  exp1(ls);  /* limit */
-  if (testnext(ls, ','))
-    exp1(ls);  /* optional step */
-  else {  /* default step = 1 */
-    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
-    luaK_reserveregs(fs, 1);
-  }
-  forbody(ls, base, line, 1, 1);
-}
-
-
-static void forlist (LexState *ls, TString *indexname) {
-  /* forlist -> NAME {,NAME} IN explist1 forbody */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int nvars = 0;
-  int line;
-  int base = fs->freereg;
-  /* create control variables */
-  new_localvarliteral(ls, "(for generator)", nvars++);
-  new_localvarliteral(ls, "(for state)", nvars++);
-  new_localvarliteral(ls, "(for control)", nvars++);
-  /* create declared variables */
-  new_localvar(ls, indexname, nvars++);
-  while (testnext(ls, ','))
-    new_localvar(ls, str_checkname(ls), nvars++);
-  checknext(ls, TK_IN);
-  line = ls->linenumber;
-  adjust_assign(ls, 3, explist1(ls, &e), &e);
-  luaK_checkstack(fs, 3);  /* extra space to call generator */
-  forbody(ls, base, line, nvars - 3, 0);
-}
-
-
-static void forstat (LexState *ls, int line) {
-  /* forstat -> FOR (fornum | forlist) END */
-  FuncState *fs = ls->fs;
-  TString *varname;
-  BlockCnt bl;
-  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
-  luaX_next(ls);  /* skip `for' */
-  varname = str_checkname(ls);  /* first variable name */
-  switch (ls->t.token) {
-    case '=': fornum(ls, varname, line); break;
-    case ',': case TK_IN: forlist(ls, varname); break;
-    default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
-  }
-  check_match(ls, TK_END, TK_FOR, line);
-  leaveblock(fs);  /* loop scope (`break' jumps to this point) */
-}
-
-
-static int test_then_block (LexState *ls) {
-  /* test_then_block -> [IF | ELSEIF] cond THEN block */
-  int condexit;
-  luaX_next(ls);  /* skip IF or ELSEIF */
-  condexit = cond(ls);
-  checknext(ls, TK_THEN);
-  block(ls);  /* `then' part */
-  return condexit;
-}
-
-
-static void ifstat (LexState *ls, int line) {
-  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
-  FuncState *fs = ls->fs;
-  int flist;
-  int escapelist = NO_JUMP;
-  flist = test_then_block(ls);  /* IF cond THEN block */
-  while (ls->t.token == TK_ELSEIF) {
-    luaK_concat(fs, &escapelist, luaK_jump(fs));
-    luaK_patchtohere(fs, flist);
-    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
-  }
-  if (ls->t.token == TK_ELSE) {
-    luaK_concat(fs, &escapelist, luaK_jump(fs));
-    luaK_patchtohere(fs, flist);
-    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
-    block(ls);  /* `else' part */
-  }
-  else
-    luaK_concat(fs, &escapelist, flist);
-  luaK_patchtohere(fs, escapelist);
-  check_match(ls, TK_END, TK_IF, line);
-}
-
-
-static void localfunc (LexState *ls) {
-  expdesc v, b;
-  FuncState *fs = ls->fs;
-  new_localvar(ls, str_checkname(ls), 0);
-  init_exp(&v, VLOCAL, fs->freereg);
-  luaK_reserveregs(fs, 1);
-  adjustlocalvars(ls, 1);
-  body(ls, &b, 0, ls->linenumber);
-  luaK_storevar(fs, &v, &b);
-  /* debug information will only see the variable after this point! */
-  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
-}
-
-
-static void localstat (LexState *ls) {
-  /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
-  int nvars = 0;
-  int nexps;
-  expdesc e;
-  do {
-    new_localvar(ls, str_checkname(ls), nvars++);
-  } while (testnext(ls, ','));
-  if (testnext(ls, '='))
-    nexps = explist1(ls, &e);
-  else {
-    e.k = VVOID;
-    nexps = 0;
-  }
-  adjust_assign(ls, nvars, nexps, &e);
-  adjustlocalvars(ls, nvars);
-}
-
-
-static int funcname (LexState *ls, expdesc *v) {
-  /* funcname -> NAME {field} [`:' NAME] */
-  int needself = 0;
-  singlevar(ls, v);
-  while (ls->t.token == '.')
-    field(ls, v);
-  if (ls->t.token == ':') {
-    needself = 1;
-    field(ls, v);
-  }
-  return needself;
-}
-
-
-static void funcstat (LexState *ls, int line) {
-  /* funcstat -> FUNCTION funcname body */
-  int needself;
-  expdesc v, b;
-  luaX_next(ls);  /* skip FUNCTION */
-  needself = funcname(ls, &v);
-  body(ls, &b, needself, line);
-  luaK_storevar(ls->fs, &v, &b);
-  luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
-}
-
-
-static void exprstat (LexState *ls) {
-  /* stat -> func | assignment */
-  FuncState *fs = ls->fs;
-  struct LHS_assign v;
-  primaryexp(ls, &v.v);
-  if (v.v.k == VCALL)  /* stat -> func */
-    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
-  else {  /* stat -> assignment */
-    v.prev = NULL;
-    assignment(ls, &v, 1);
-  }
-}
-
-
-static void retstat (LexState *ls) {
-  /* stat -> RETURN explist */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int first, nret;  /* registers with returned values */
-  luaX_next(ls);  /* skip RETURN */
-  if (block_follow(ls->t.token) || ls->t.token == ';')
-    first = nret = 0;  /* return no values */
-  else {
-    nret = explist1(ls, &e);  /* optional return values */
-    if (hasmultret(e.k)) {
-      luaK_setmultret(fs, &e);
-      if (e.k == VCALL && nret == 1) {  /* tail call? */
-        SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
-        lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
-      }
-      first = fs->nactvar;
-      nret = LUA_MULTRET;  /* return all values */
-    }
-    else {
-      if (nret == 1)  /* only one single value? */
-        first = luaK_exp2anyreg(fs, &e);
-      else {
-        luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
-        first = fs->nactvar;  /* return all `active' values */
-        lua_assert(nret == fs->freereg - first);
-      }
-    }
-  }
-  luaK_ret(fs, first, nret);
-}
-
-
-static int statement (LexState *ls) {
-  int line = ls->linenumber;  /* may be needed for error messages */
-  switch (ls->t.token) {
-    case TK_IF: {  /* stat -> ifstat */
-      ifstat(ls, line);
-      return 0;
-    }
-    case TK_WHILE: {  /* stat -> whilestat */
-      whilestat(ls, line);
-      return 0;
-    }
-    case TK_DO: {  /* stat -> DO block END */
-      luaX_next(ls);  /* skip DO */
-      block(ls);
-      check_match(ls, TK_END, TK_DO, line);
-      return 0;
-    }
-    case TK_FOR: {  /* stat -> forstat */
-      forstat(ls, line);
-      return 0;
-    }
-    case TK_REPEAT: {  /* stat -> repeatstat */
-      repeatstat(ls, line);
-      return 0;
-    }
-    case TK_FUNCTION: {
-      funcstat(ls, line);  /* stat -> funcstat */
-      return 0;
-    }
-    case TK_LOCAL: {  /* stat -> localstat */
-      luaX_next(ls);  /* skip LOCAL */
-      if (testnext(ls, TK_FUNCTION))  /* local function? */
-        localfunc(ls);
-      else
-        localstat(ls);
-      return 0;
-    }
-    case TK_RETURN: {  /* stat -> retstat */
-      retstat(ls);
-      return 1;  /* must be last statement */
-    }
-    case TK_BREAK: {  /* stat -> breakstat */
-      luaX_next(ls);  /* skip BREAK */
-      breakstat(ls);
-      return 1;  /* must be last statement */
-    }
-    default: {
-      exprstat(ls);
-      return 0;  /* to avoid warnings */
-    }
-  }
-}
-
-
-static void chunk (LexState *ls) {
-  /* chunk -> { stat [`;'] } */
-  int islast = 0;
-  enterlevel(ls);
-  while (!islast && !block_follow(ls->t.token)) {
-    islast = statement(ls);
-    testnext(ls, ';');
-    lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
-               ls->fs->freereg >= ls->fs->nactvar);
-    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
-  }
-  leavelevel(ls);
-}
-
-/* }====================================================================== */

diff --git a/source3/lua-5.1.4/src/lparser.h b/source3/lua-5.1.4/src/lparser.h
deleted file mode 100644 (file)
index 18836af..0000000
--- a/source3/lua-5.1.4/src/lparser.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lparser_h
-#define lparser_h
-
-#include "llimits.h"
-#include "lobject.h"
-#include "lzio.h"
-
-
-/*
-** Expression descriptor
-*/
-
-typedef enum {
-  VVOID,       /* no value */
-  VNIL,
-  VTRUE,
-  VFALSE,
-  VK,          /* info = index of constant in `k' */
-  VKNUM,       /* nval = numerical value */
-  VLOCAL,      /* info = local register */
-  VUPVAL,       /* info = index of upvalue in `upvalues' */
-  VGLOBAL,     /* info = index of table; aux = index of global name in `k' */
-  VINDEXED,    /* info = table register; aux = index register (or `k') */
-  VJMP,                /* info = instruction pc */
-  VRELOCABLE,  /* info = instruction pc */
-  VNONRELOC,   /* info = result register */
-  VCALL,       /* info = instruction pc */
-  VVARARG      /* info = instruction pc */
-} expkind;
-
-typedef struct expdesc {
-  expkind k;
-  union {
-    struct { int info, aux; } s;
-    lua_Number nval;
-  } u;
-  int t;  /* patch list of `exit when true' */
-  int f;  /* patch list of `exit when false' */
-} expdesc;
-
-
-typedef struct upvaldesc {
-  lu_byte k;
-  lu_byte info;
-} upvaldesc;
-
-
-struct BlockCnt;  /* defined in lparser.c */
-
-
-/* state needed to generate code for a given function */
-typedef struct FuncState {
-  Proto *f;  /* current function header */
-  Table *h;  /* table to find (and reuse) elements in `k' */
-  struct FuncState *prev;  /* enclosing function */
-  struct LexState *ls;  /* lexical state */
-  struct lua_State *L;  /* copy of the Lua state */
-  struct BlockCnt *bl;  /* chain of current blocks */
-  int pc;  /* next position to code (equivalent to `ncode') */
-  int lasttarget;   /* `pc' of last `jump target' */
-  int jpc;  /* list of pending jumps to `pc' */
-  int freereg;  /* first free register */
-  int nk;  /* number of elements in `k' */
-  int np;  /* number of elements in `p' */
-  short nlocvars;  /* number of elements in `locvars' */
-  lu_byte nactvar;  /* number of active local variables */
-  upvaldesc upvalues[LUAI_MAXUPVALUES];  /* upvalues */
-  unsigned short actvar[LUAI_MAXVARS];  /* declared-variable stack */
-} FuncState;
-
-
-LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                                            const char *name);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/lstate.c b/source3/lua-5.1.4/src/lstate.c
deleted file mode 100644 (file)
index 0c1b97f..0000000
--- a/source3/lua-5.1.4/src/lstate.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
-** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define lstate_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-#define state_size(x)  (sizeof(x) + LUAI_EXTRASPACE)
-#define fromstate(l)   (cast(lu_byte *, (l)) - LUAI_EXTRASPACE)
-#define tostate(l)   (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE))
-
-
-/*
-** Main thread combines a thread state and the global state
-*/
-typedef struct LG {
-  lua_State l;
-  global_State g;
-} LG;
-
-
-
-static void stack_init (lua_State *L1, lua_State *L) {
-  /* initialize CallInfo array */
-  L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
-  L1->ci = L1->base_ci;
-  L1->size_ci = BASIC_CI_SIZE;
-  L1->end_ci = L1->base_ci + L1->size_ci - 1;
-  /* initialize stack array */
-  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
-  L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
-  L1->top = L1->stack;
-  L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
-  /* initialize first ci */
-  L1->ci->func = L1->top;
-  setnilvalue(L1->top++);  /* `function' entry for this `ci' */
-  L1->base = L1->ci->base = L1->top;
-  L1->ci->top = L1->top + LUA_MINSTACK;
-}
-
-
-static void freestack (lua_State *L, lua_State *L1) {
-  luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
-  luaM_freearray(L, L1->stack, L1->stacksize, TValue);
-}
-
-
-/*
-** open parts that may cause memory-allocation errors
-*/
-static void f_luaopen (lua_State *L, void *ud) {
-  global_State *g = G(L);
-  UNUSED(ud);
-  stack_init(L, L);  /* init stack */
-  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
-  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
-  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
-  luaT_init(L);
-  luaX_init(L);
-  luaS_fix(luaS_newliteral(L, MEMERRMSG));
-  g->GCthreshold = 4*g->totalbytes;
-}
-
-
-static void preinit_state (lua_State *L, global_State *g) {
-  G(L) = g;
-  L->stack = NULL;
-  L->stacksize = 0;
-  L->errorJmp = NULL;
-  L->hook = NULL;
-  L->hookmask = 0;
-  L->basehookcount = 0;
-  L->allowhook = 1;
-  resethookcount(L);
-  L->openupval = NULL;
-  L->size_ci = 0;
-  L->nCcalls = L->baseCcalls = 0;
-  L->status = 0;
-  L->base_ci = L->ci = NULL;
-  L->savedpc = NULL;
-  L->errfunc = 0;
-  setnilvalue(gt(L));
-}
-
-
-static void close_state (lua_State *L) {
-  global_State *g = G(L);
-  luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_freeall(L);  /* collect all objects */
-  lua_assert(g->rootgc == obj2gco(L));
-  lua_assert(g->strt.nuse == 0);
-  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
-  luaZ_freebuffer(L, &g->buff);
-  freestack(L, L);
-  lua_assert(g->totalbytes == sizeof(LG));
-  (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
-}
-
-
-lua_State *luaE_newthread (lua_State *L) {
-  lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
-  luaC_link(L, obj2gco(L1), LUA_TTHREAD);
-  preinit_state(L1, G(L));
-  stack_init(L1, L);  /* init stack */
-  setobj2n(L, gt(L1), gt(L));  /* share table of globals */
-  L1->hookmask = L->hookmask;
-  L1->basehookcount = L->basehookcount;
-  L1->hook = L->hook;
-  resethookcount(L1);
-  lua_assert(iswhite(obj2gco(L1)));
-  return L1;
-}
-
-
-void luaE_freethread (lua_State *L, lua_State *L1) {
-  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
-  lua_assert(L1->openupval == NULL);
-  luai_userstatefree(L1);
-  freestack(L, L1);
-  luaM_freemem(L, fromstate(L1), state_size(lua_State));
-}
-
-
-LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
-  int i;
-  lua_State *L;
-  global_State *g;
-  void *l = (*f)(ud, NULL, 0, state_size(LG));
-  if (l == NULL) return NULL;
-  L = tostate(l);
-  g = &((LG *)L)->g;
-  L->next = NULL;
-  L->tt = LUA_TTHREAD;
-  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
-  L->marked = luaC_white(g);
-  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
-  preinit_state(L, g);
-  g->frealloc = f;
-  g->ud = ud;
-  g->mainthread = L;
-  g->uvhead.u.l.prev = &g->uvhead;
-  g->uvhead.u.l.next = &g->uvhead;
-  g->GCthreshold = 0;  /* mark it as unfinished state */
-  g->strt.size = 0;
-  g->strt.nuse = 0;
-  g->strt.hash = NULL;
-  setnilvalue(registry(L));
-  luaZ_initbuffer(L, &g->buff);
-  g->panic = NULL;
-  g->gcstate = GCSpause;
-  g->rootgc = obj2gco(L);
-  g->sweepstrgc = 0;
-  g->sweepgc = &g->rootgc;
-  g->gray = NULL;
-  g->grayagain = NULL;
-  g->weak = NULL;
-  g->tmudata = NULL;
-  g->totalbytes = sizeof(LG);
-  g->gcpause = LUAI_GCPAUSE;
-  g->gcstepmul = LUAI_GCMUL;
-  g->gcdept = 0;
-  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
-  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
-    /* memory allocation error: free partial state */
-    close_state(L);
-    L = NULL;
-  }
-  else
-    luai_userstateopen(L);
-  return L;
-}
-
-
-static void callallgcTM (lua_State *L, void *ud) {
-  UNUSED(ud);
-  luaC_callGCTM(L);  /* call GC metamethods for all udata */
-}
-
-
-LUA_API void lua_close (lua_State *L) {
-  L = G(L)->mainthread;  /* only the main thread can be closed */
-  lua_lock(L);
-  luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
-  L->errfunc = 0;  /* no error function during GC metamethods */
-  do {  /* repeat until no more errors */
-    L->ci = L->base_ci;
-    L->base = L->top = L->ci->base;
-    L->nCcalls = L->baseCcalls = 0;
-  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
-  lua_assert(G(L)->tmudata == NULL);
-  luai_userstateclose(L);
-  close_state(L);
-}

diff --git a/source3/lua-5.1.4/src/lstate.h b/source3/lua-5.1.4/src/lstate.h
deleted file mode 100644 (file)
index 8297628..0000000
--- a/source3/lua-5.1.4/src/lstate.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lstate_h
-#define lstate_h
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "ltm.h"
-#include "lzio.h"
-
-
-
-struct lua_longjmp;  /* defined in ldo.c */
-
-
-/* table of globals */
-#define gt(L)  (&L->l_gt)
-
-/* registry */
-#define registry(L)    (&G(L)->l_registry)
-
-
-/* extra stack space to handle TM calls and some other extras */
-#define EXTRA_STACK   5
-
-
-#define BASIC_CI_SIZE           8
-
-#define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
-
-
-
-typedef struct stringtable {
-  GCObject **hash;
-  lu_int32 nuse;  /* number of elements */
-  int size;
-} stringtable;
-
-
-/*
-** informations about a call
-*/
-typedef struct CallInfo {
-  StkId base;  /* base for this function */
-  StkId func;  /* function index in the stack */
-  StkId        top;  /* top for this function */
-  const Instruction *savedpc;
-  int nresults;  /* expected number of results from this function */
-  int tailcalls;  /* number of tail calls lost under this entry */
-} CallInfo;
-
-
-
-#define curr_func(L)   (clvalue(L->ci->func))
-#define ci_func(ci)    (clvalue((ci)->func))
-#define f_isLua(ci)    (!ci_func(ci)->c.isC)
-#define isLua(ci)      (ttisfunction((ci)->func) && f_isLua(ci))
-
-
-/*
-** `global state', shared by all threads of this state
-*/
-typedef struct global_State {
-  stringtable strt;  /* hash table for strings */
-  lua_Alloc frealloc;  /* function to reallocate memory */
-  void *ud;         /* auxiliary data to `frealloc' */
-  lu_byte currentwhite;
-  lu_byte gcstate;  /* state of garbage collector */
-  int sweepstrgc;  /* position of sweep in `strt' */
-  GCObject *rootgc;  /* list of all collectable objects */
-  GCObject **sweepgc;  /* position of sweep in `rootgc' */
-  GCObject *gray;  /* list of gray objects */
-  GCObject *grayagain;  /* list of objects to be traversed atomically */
-  GCObject *weak;  /* list of weak tables (to be cleared) */
-  GCObject *tmudata;  /* last element of list of userdata to be GC */
-  Mbuffer buff;  /* temporary buffer for string concatentation */
-  lu_mem GCthreshold;
-  lu_mem totalbytes;  /* number of bytes currently allocated */
-  lu_mem estimate;  /* an estimate of number of bytes actually in use */
-  lu_mem gcdept;  /* how much GC is `behind schedule' */
-  int gcpause;  /* size of pause between successive GCs */
-  int gcstepmul;  /* GC `granularity' */
-  lua_CFunction panic;  /* to be called in unprotected errors */
-  TValue l_registry;
-  struct lua_State *mainthread;
-  UpVal uvhead;  /* head of double-linked list of all open upvalues */
-  struct Table *mt[NUM_TAGS];  /* metatables for basic types */
-  TString *tmname[TM_N];  /* array with tag-method names */
-} global_State;
-
-
-/*
-** `per thread' state
-*/
-struct lua_State {
-  CommonHeader;
-  lu_byte status;
-  StkId top;  /* first free slot in the stack */
-  StkId base;  /* base of current function */
-  global_State *l_G;
-  CallInfo *ci;  /* call info for current function */
-  const Instruction *savedpc;  /* `savedpc' of current function */
-  StkId stack_last;  /* last free slot in the stack */
-  StkId stack;  /* stack base */
-  CallInfo *end_ci;  /* points after end of ci array*/
-  CallInfo *base_ci;  /* array of CallInfo's */
-  int stacksize;
-  int size_ci;  /* size of array `base_ci' */
-  unsigned short nCcalls;  /* number of nested C calls */
-  unsigned short baseCcalls;  /* nested C calls when resuming coroutine */
-  lu_byte hookmask;
-  lu_byte allowhook;
-  int basehookcount;
-  int hookcount;
-  lua_Hook hook;
-  TValue l_gt;  /* table of globals */
-  TValue env;  /* temporary place for environments */
-  GCObject *openupval;  /* list of open upvalues in this stack */
-  GCObject *gclist;
-  struct lua_longjmp *errorJmp;  /* current error recover point */
-  ptrdiff_t errfunc;  /* current error handling function (stack index) */
-};
-
-
-#define G(L)   (L->l_G)
-
-
-/*
-** Union of all collectable objects
-*/
-union GCObject {
-  GCheader gch;
-  union TString ts;
-  union Udata u;
-  union Closure cl;
-  struct Table h;
-  struct Proto p;
-  struct UpVal uv;
-  struct lua_State th;  /* thread */
-};
-
-
-/* macros to convert a GCObject into a specific value */
-#define rawgco2ts(o)   check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
-#define gco2ts(o)      (&rawgco2ts(o)->tsv)
-#define rawgco2u(o)    check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
-#define gco2u(o)       (&rawgco2u(o)->uv)
-#define gco2cl(o)      check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))
-#define gco2h(o)       check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
-#define gco2p(o)       check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
-#define gco2uv(o)      check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
-#define ngcotouv(o) \
-       check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))
-#define gco2th(o)      check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
-
-/* macro to convert any Lua object into a GCObject */
-#define obj2gco(v)     (cast(GCObject *, (v)))
-
-
-LUAI_FUNC lua_State *luaE_newthread (lua_State *L);
-LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
-
-#endif

diff --git a/source3/lua-5.1.4/src/lstring.c b/source3/lua-5.1.4/src/lstring.c
deleted file mode 100644 (file)
index afc851d..0000000
--- a/source3/lua-5.1.4/src/lstring.c
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
-** String table (keeps all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define lstring_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-
-
-
-void luaS_resize (lua_State *L, int newsize) {
-  GCObject **newhash;
-  stringtable *tb;
-  int i;
-  if (G(L)->gcstate == GCSsweepstring)
-    return;  /* cannot resize during GC traverse */
-  newhash = luaM_newvector(L, newsize, GCObject *);
-  tb = &G(L)->strt;
-  for (i=0; i<newsize; i++) newhash[i] = NULL;
-  /* rehash */
-  for (i=0; i<tb->size; i++) {
-    GCObject *p = tb->hash[i];
-    while (p) {  /* for each node in the list */
-      GCObject *next = p->gch.next;  /* save next */
-      unsigned int h = gco2ts(p)->hash;
-      int h1 = lmod(h, newsize);  /* new position */
-      lua_assert(cast_int(h%newsize) == lmod(h, newsize));
-      p->gch.next = newhash[h1];  /* chain it */
-      newhash[h1] = p;
-      p = next;
-    }
-  }
-  luaM_freearray(L, tb->hash, tb->size, TString *);
-  tb->size = newsize;
-  tb->hash = newhash;
-}
-
-
-static TString *newlstr (lua_State *L, const char *str, size_t l,
-                                       unsigned int h) {
-  TString *ts;
-  stringtable *tb;
-  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
-    luaM_toobig(L);
-  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
-  ts->tsv.len = l;
-  ts->tsv.hash = h;
-  ts->tsv.marked = luaC_white(G(L));
-  ts->tsv.tt = LUA_TSTRING;
-  ts->tsv.reserved = 0;
-  memcpy(ts+1, str, l*sizeof(char));
-  ((char *)(ts+1))[l] = '\0';  /* ending 0 */
-  tb = &G(L)->strt;
-  h = lmod(h, tb->size);
-  ts->tsv.next = tb->hash[h];  /* chain new entry */
-  tb->hash[h] = obj2gco(ts);
-  tb->nuse++;
-  if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
-    luaS_resize(L, tb->size*2);  /* too crowded */
-  return ts;
-}
-
-
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
-  unsigned int h = cast(unsigned int, l);  /* seed */
-  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
-  size_t l1;
-  for (l1=l; l1>=step; l1-=step)  /* compute hash */
-    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
-  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
-       o != NULL;
-       o = o->gch.next) {
-    TString *ts = rawgco2ts(o);
-    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
-      /* string may be dead */
-      if (isdead(G(L), o)) changewhite(o);
-      return ts;
-    }
-  }
-  return newlstr(L, str, l, h);  /* not found */
-}
-
-
-Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
-  Udata *u;
-  if (s > MAX_SIZET - sizeof(Udata))
-    luaM_toobig(L);
-  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
-  u->uv.marked = luaC_white(G(L));  /* is not finalized */
-  u->uv.tt = LUA_TUSERDATA;
-  u->uv.len = s;
-  u->uv.metatable = NULL;
-  u->uv.env = e;
-  /* chain it on udata list (after main thread) */
-  u->uv.next = G(L)->mainthread->next;
-  G(L)->mainthread->next = obj2gco(u);
-  return u;
-}

diff --git a/source3/lua-5.1.4/src/lstring.h b/source3/lua-5.1.4/src/lstring.h
deleted file mode 100644 (file)
index 73a2ff8..0000000
--- a/source3/lua-5.1.4/src/lstring.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $
-** String table (keep all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lstring_h
-#define lstring_h
-
-
-#include "lgc.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-#define sizestring(s)  (sizeof(union TString)+((s)->len+1)*sizeof(char))
-
-#define sizeudata(u)   (sizeof(union Udata)+(u)->len)
-
-#define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s)))
-#define luaS_newliteral(L, s)  (luaS_newlstr(L, "" s, \
-                                 (sizeof(s)/sizeof(char))-1))
-
-#define luaS_fix(s)    l_setbit((s)->tsv.marked, FIXEDBIT)
-
-LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
-LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/lstrlib.c b/source3/lua-5.1.4/src/lstrlib.c
deleted file mode 100644 (file)
index 0f5a2dd..0000000
--- a/source3/lua-5.1.4/src/lstrlib.c
+++ /dev/null
@@ -1,868 +0,0 @@
-/*
-** $Id: lstrlib.c,v 1.132.1.4 2008/07/11 17:27:21 roberto Exp $
-** Standard library for string operations and pattern-matching
-** See Copyright Notice in lua.h
-*/
-
-
-#include <ctype.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lstrlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/* macro to `unsign' a character */
-#define uchar(c)        ((unsigned char)(c))
-
-
-
-static int str_len (lua_State *L) {
-  size_t l;
-  luaL_checklstring(L, 1, &l);
-  lua_pushinteger(L, l);
-  return 1;
-}
-
-
-static ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {
-  /* relative string position: negative means back from end */
-  if (pos < 0) pos += (ptrdiff_t)len + 1;
-  return (pos >= 0) ? pos : 0;
-}
-
-
-static int str_sub (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
-  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
-  if (start < 1) start = 1;
-  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
-  if (start <= end)
-    lua_pushlstring(L, s+start-1, end-start+1);
-  else lua_pushliteral(L, "");
-  return 1;
-}
-
-
-static int str_reverse (lua_State *L) {
-  size_t l;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  luaL_buffinit(L, &b);
-  while (l--) luaL_addchar(&b, s[l]);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_lower (lua_State *L) {
-  size_t l;
-  size_t i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  luaL_buffinit(L, &b);
-  for (i=0; i<l; i++)
-    luaL_addchar(&b, tolower(uchar(s[i])));
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_upper (lua_State *L) {
-  size_t l;
-  size_t i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  luaL_buffinit(L, &b);
-  for (i=0; i<l; i++)
-    luaL_addchar(&b, toupper(uchar(s[i])));
-  luaL_pushresult(&b);
-  return 1;
-}
-
-static int str_rep (lua_State *L) {
-  size_t l;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  int n = luaL_checkint(L, 2);
-  luaL_buffinit(L, &b);
-  while (n-- > 0)
-    luaL_addlstring(&b, s, l);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_byte (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
-  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
-  int n, i;
-  if (posi <= 0) posi = 1;
-  if ((size_t)pose > l) pose = l;
-  if (posi > pose) return 0;  /* empty interval; return no values */
-  n = (int)(pose -  posi + 1);
-  if (posi + n <= pose)  /* overflow? */
-    luaL_error(L, "string slice too long");
-  luaL_checkstack(L, n, "string slice too long");
-  for (i=0; i<n; i++)
-    lua_pushinteger(L, uchar(s[posi+i-1]));
-  return n;
-}
-
-
-static int str_char (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  for (i=1; i<=n; i++) {
-    int c = luaL_checkint(L, i);
-    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
-    luaL_addchar(&b, uchar(c));
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int writer (lua_State *L, const void* b, size_t size, void* B) {
-  (void)L;
-  luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
-  return 0;
-}
-
-
-static int str_dump (lua_State *L) {
-  luaL_Buffer b;
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  lua_settop(L, 1);
-  luaL_buffinit(L,&b);
-  if (lua_dump(L, writer, &b) != 0)
-    luaL_error(L, "unable to dump given function");
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-
-/*
-** {======================================================
-** PATTERN MATCHING
-** =======================================================
-*/
-
-
-#define CAP_UNFINISHED (-1)
-#define CAP_POSITION   (-2)
-
-typedef struct MatchState {
-  const char *src_init;  /* init of source string */
-  const char *src_end;  /* end (`\0') of source string */
-  lua_State *L;
-  int level;  /* total number of captures (finished or unfinished) */
-  struct {
-    const char *init;
-    ptrdiff_t len;
-  } capture[LUA_MAXCAPTURES];
-} MatchState;
-
-
-#define L_ESC          '%'
-#define SPECIALS       "^$*+?.([%-"
-
-
-static int check_capture (MatchState *ms, int l) {
-  l -= '1';
-  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
-    return luaL_error(ms->L, "invalid capture index");
-  return l;
-}
-
-
-static int capture_to_close (MatchState *ms) {
-  int level = ms->level;
-  for (level--; level>=0; level--)
-    if (ms->capture[level].len == CAP_UNFINISHED) return level;
-  return luaL_error(ms->L, "invalid pattern capture");
-}
-
-
-static const char *classend (MatchState *ms, const char *p) {
-  switch (*p++) {
-    case L_ESC: {
-      if (*p == '\0')
-        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
-      return p+1;
-    }
-    case '[': {
-      if (*p == '^') p++;
-      do {  /* look for a `]' */
-        if (*p == '\0')
-          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
-        if (*(p++) == L_ESC && *p != '\0')
-          p++;  /* skip escapes (e.g. `%]') */
-      } while (*p != ']');
-      return p+1;
-    }
-    default: {
-      return p;
-    }
-  }
-}
-
-
-static int match_class (int c, int cl) {
-  int res;
-  switch (tolower(cl)) {
-    case 'a' : res = isalpha(c); break;
-    case 'c' : res = iscntrl(c); break;
-    case 'd' : res = isdigit(c); break;
-    case 'l' : res = islower(c); break;
-    case 'p' : res = ispunct(c); break;
-    case 's' : res = isspace(c); break;
-    case 'u' : res = isupper(c); break;
-    case 'w' : res = isalnum(c); break;
-    case 'x' : res = isxdigit(c); break;
-    case 'z' : res = (c == 0); break;
-    default: return (cl == c);
-  }
-  return (islower(cl) ? res : !res);
-}
-
-
-static int matchbracketclass (int c, const char *p, const char *ec) {
-  int sig = 1;
-  if (*(p+1) == '^') {
-    sig = 0;
-    p++;  /* skip the `^' */
-  }
-  while (++p < ec) {
-    if (*p == L_ESC) {
-      p++;
-      if (match_class(c, uchar(*p)))
-        return sig;
-    }
-    else if ((*(p+1) == '-') && (p+2 < ec)) {
-      p+=2;
-      if (uchar(*(p-2)) <= c && c <= uchar(*p))
-        return sig;
-    }
-    else if (uchar(*p) == c) return sig;
-  }
-  return !sig;
-}
-
-
-static int singlematch (int c, const char *p, const char *ep) {
-  switch (*p) {
-    case '.': return 1;  /* matches any char */
-    case L_ESC: return match_class(c, uchar(*(p+1)));
-    case '[': return matchbracketclass(c, p, ep-1);
-    default:  return (uchar(*p) == c);
-  }
-}
-
-
-static const char *match (MatchState *ms, const char *s, const char *p);
-
-
-static const char *matchbalance (MatchState *ms, const char *s,
-                                   const char *p) {
-  if (*p == 0 || *(p+1) == 0)
-    luaL_error(ms->L, "unbalanced pattern");
-  if (*s != *p) return NULL;
-  else {
-    int b = *p;
-    int e = *(p+1);
-    int cont = 1;
-    while (++s < ms->src_end) {
-      if (*s == e) {
-        if (--cont == 0) return s+1;
-      }
-      else if (*s == b) cont++;
-    }
-  }
-  return NULL;  /* string ends out of balance */
-}
-
-
-static const char *max_expand (MatchState *ms, const char *s,
-                                 const char *p, const char *ep) {
-  ptrdiff_t i = 0;  /* counts maximum expand for item */
-  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
-    i++;
-  /* keeps trying to match with the maximum repetitions */
-  while (i>=0) {
-    const char *res = match(ms, (s+i), ep+1);
-    if (res) return res;
-    i--;  /* else didn't match; reduce 1 repetition to try again */
-  }
-  return NULL;
-}
-
-
-static const char *min_expand (MatchState *ms, const char *s,
-                                 const char *p, const char *ep) {
-  for (;;) {
-    const char *res = match(ms, s, ep+1);
-    if (res != NULL)
-      return res;
-    else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
-      s++;  /* try with one more repetition */
-    else return NULL;
-  }
-}
-
-
-static const char *start_capture (MatchState *ms, const char *s,
-                                    const char *p, int what) {
-  const char *res;
-  int level = ms->level;
-  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
-  ms->capture[level].init = s;
-  ms->capture[level].len = what;
-  ms->level = level+1;
-  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
-    ms->level--;  /* undo capture */
-  return res;
-}
-
-
-static const char *end_capture (MatchState *ms, const char *s,
-                                  const char *p) {
-  int l = capture_to_close(ms);
-  const char *res;
-  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
-  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
-    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
-  return res;
-}
-
-
-static const char *match_capture (MatchState *ms, const char *s, int l) {
-  size_t len;
-  l = check_capture(ms, l);
-  len = ms->capture[l].len;
-  if ((size_t)(ms->src_end-s) >= len &&
-      memcmp(ms->capture[l].init, s, len) == 0)
-    return s+len;
-  else return NULL;
-}
-
-
-static const char *match (MatchState *ms, const char *s, const char *p) {
-  init: /* using goto's to optimize tail recursion */
-  switch (*p) {
-    case '(': {  /* start capture */
-      if (*(p+1) == ')')  /* position capture? */
-        return start_capture(ms, s, p+2, CAP_POSITION);
-      else
-        return start_capture(ms, s, p+1, CAP_UNFINISHED);
-    }
-    case ')': {  /* end capture */
-      return end_capture(ms, s, p+1);
-    }
-    case L_ESC: {
-      switch (*(p+1)) {
-        case 'b': {  /* balanced string? */
-          s = matchbalance(ms, s, p+2);
-          if (s == NULL) return NULL;
-          p+=4; goto init;  /* else return match(ms, s, p+4); */
-        }
-        case 'f': {  /* frontier? */
-          const char *ep; char previous;
-          p += 2;
-          if (*p != '[')
-            luaL_error(ms->L, "missing " LUA_QL("[") " after "
-                               LUA_QL("%%f") " in pattern");
-          ep = classend(ms, p);  /* points to what is next */
-          previous = (s == ms->src_init) ? '\0' : *(s-1);
-          if (matchbracketclass(uchar(previous), p, ep-1) ||
-             !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
-          p=ep; goto init;  /* else return match(ms, s, ep); */
-        }
-        default: {
-          if (isdigit(uchar(*(p+1)))) {  /* capture results (%0-%9)? */
-            s = match_capture(ms, s, uchar(*(p+1)));
-            if (s == NULL) return NULL;
-            p+=2; goto init;  /* else return match(ms, s, p+2) */
-          }
-          goto dflt;  /* case default */
-        }
-      }
-    }
-    case '\0': {  /* end of pattern */
-      return s;  /* match succeeded */
-    }
-    case '$': {
-      if (*(p+1) == '\0')  /* is the `$' the last char in pattern? */
-        return (s == ms->src_end) ? s : NULL;  /* check end of string */
-      else goto dflt;
-    }
-    default: dflt: {  /* it is a pattern item */
-      const char *ep = classend(ms, p);  /* points to what is next */
-      int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
-      switch (*ep) {
-        case '?': {  /* optional */
-          const char *res;
-          if (m && ((res=match(ms, s+1, ep+1)) != NULL))
-            return res;
-          p=ep+1; goto init;  /* else return match(ms, s, ep+1); */
-        }
-        case '*': {  /* 0 or more repetitions */
-          return max_expand(ms, s, p, ep);
-        }
-        case '+': {  /* 1 or more repetitions */
-          return (m ? max_expand(ms, s+1, p, ep) : NULL);
-        }
-        case '-': {  /* 0 or more repetitions (minimum) */
-          return min_expand(ms, s, p, ep);
-        }
-        default: {
-          if (!m) return NULL;
-          s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */
-        }
-      }
-    }
-  }
-}
-
-
-
-static const char *lmemfind (const char *s1, size_t l1,
-                               const char *s2, size_t l2) {
-  if (l2 == 0) return s1;  /* empty strings are everywhere */
-  else if (l2 > l1) return NULL;  /* avoids a negative `l1' */
-  else {
-    const char *init;  /* to search for a `*s2' inside `s1' */
-    l2--;  /* 1st char will be checked by `memchr' */
-    l1 = l1-l2;  /* `s2' cannot be found after that */
-    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
-      init++;   /* 1st char is already checked */
-      if (memcmp(init, s2+1, l2) == 0)
-        return init-1;
-      else {  /* correct `l1' and `s1' to try again */
-        l1 -= init-s1;
-        s1 = init;
-      }
-    }
-    return NULL;  /* not found */
-  }
-}
-
-
-static void push_onecapture (MatchState *ms, int i, const char *s,
-                                                    const char *e) {
-  if (i >= ms->level) {
-    if (i == 0)  /* ms->level == 0, too */
-      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
-    else
-      luaL_error(ms->L, "invalid capture index");
-  }
-  else {
-    ptrdiff_t l = ms->capture[i].len;
-    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
-    if (l == CAP_POSITION)
-      lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
-    else
-      lua_pushlstring(ms->L, ms->capture[i].init, l);
-  }
-}
-
-
-static int push_captures (MatchState *ms, const char *s, const char *e) {
-  int i;
-  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
-  luaL_checkstack(ms->L, nlevels, "too many captures");
-  for (i = 0; i < nlevels; i++)
-    push_onecapture(ms, i, s, e);
-  return nlevels;  /* number of strings pushed */
-}
-
-
-static int str_find_aux (lua_State *L, int find) {
-  size_t l1, l2;
-  const char *s = luaL_checklstring(L, 1, &l1);
-  const char *p = luaL_checklstring(L, 2, &l2);
-  ptrdiff_t init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;
-  if (init < 0) init = 0;
-  else if ((size_t)(init) > l1) init = (ptrdiff_t)l1;
-  if (find && (lua_toboolean(L, 4) ||  /* explicit request? */
-      strpbrk(p, SPECIALS) == NULL)) {  /* or no special characters? */
-    /* do a plain search */
-    const char *s2 = lmemfind(s+init, l1-init, p, l2);
-    if (s2) {
-      lua_pushinteger(L, s2-s+1);
-      lua_pushinteger(L, s2-s+l2);
-      return 2;
-    }
-  }
-  else {
-    MatchState ms;
-    int anchor = (*p == '^') ? (p++, 1) : 0;
-    const char *s1=s+init;
-    ms.L = L;
-    ms.src_init = s;
-    ms.src_end = s+l1;
-    do {
-      const char *res;
-      ms.level = 0;
-      if ((res=match(&ms, s1, p)) != NULL) {
-        if (find) {
-          lua_pushinteger(L, s1-s+1);  /* start */
-          lua_pushinteger(L, res-s);   /* end */
-          return push_captures(&ms, NULL, 0) + 2;
-        }
-        else
-          return push_captures(&ms, s1, res);
-      }
-    } while (s1++ < ms.src_end && !anchor);
-  }
-  lua_pushnil(L);  /* not found */
-  return 1;
-}
-
-
-static int str_find (lua_State *L) {
-  return str_find_aux(L, 1);
-}
-
-
-static int str_match (lua_State *L) {
-  return str_find_aux(L, 0);
-}
-
-
-static int gmatch_aux (lua_State *L) {
-  MatchState ms;
-  size_t ls;
-  const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
-  const char *p = lua_tostring(L, lua_upvalueindex(2));
-  const char *src;
-  ms.L = L;
-  ms.src_init = s;
-  ms.src_end = s+ls;
-  for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
-       src <= ms.src_end;
-       src++) {
-    const char *e;
-    ms.level = 0;
-    if ((e = match(&ms, src, p)) != NULL) {
-      lua_Integer newstart = e-s;
-      if (e == src) newstart++;  /* empty match? go at least one position */
-      lua_pushinteger(L, newstart);
-      lua_replace(L, lua_upvalueindex(3));
-      return push_captures(&ms, src, e);
-    }
-  }
-  return 0;  /* not found */
-}
-
-
-static int gmatch (lua_State *L) {
-  luaL_checkstring(L, 1);
-  luaL_checkstring(L, 2);
-  lua_settop(L, 2);
-  lua_pushinteger(L, 0);
-  lua_pushcclosure(L, gmatch_aux, 3);
-  return 1;
-}
-
-
-static int gfind_nodef (lua_State *L) {
-  return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
-                       LUA_QL("string.gmatch"));
-}
-
-
-static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                   const char *e) {
-  size_t l, i;
-  const char *news = lua_tolstring(ms->L, 3, &l);
-  for (i = 0; i < l; i++) {
-    if (news[i] != L_ESC)
-      luaL_addchar(b, news[i]);
-    else {
-      i++;  /* skip ESC */
-      if (!isdigit(uchar(news[i])))
-        luaL_addchar(b, news[i]);
-      else if (news[i] == '0')
-          luaL_addlstring(b, s, e - s);
-      else {
-        push_onecapture(ms, news[i] - '1', s, e);
-        luaL_addvalue(b);  /* add capture to accumulated result */
-      }
-    }
-  }
-}
-
-
-static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                       const char *e) {
-  lua_State *L = ms->L;
-  switch (lua_type(L, 3)) {
-    case LUA_TNUMBER:
-    case LUA_TSTRING: {
-      add_s(ms, b, s, e);
-      return;
-    }
-    case LUA_TFUNCTION: {
-      int n;
-      lua_pushvalue(L, 3);
-      n = push_captures(ms, s, e);
-      lua_call(L, n, 1);
-      break;
-    }
-    case LUA_TTABLE: {
-      push_onecapture(ms, 0, s, e);
-      lua_gettable(L, 3);
-      break;
-    }
-  }
-  if (!lua_toboolean(L, -1)) {  /* nil or false? */
-    lua_pop(L, 1);
-    lua_pushlstring(L, s, e - s);  /* keep original text */
-  }
-  else if (!lua_isstring(L, -1))
-    luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1));
-  luaL_addvalue(b);  /* add result to accumulator */
-}
-
-
-static int str_gsub (lua_State *L) {
-  size_t srcl;
-  const char *src = luaL_checklstring(L, 1, &srcl);
-  const char *p = luaL_checkstring(L, 2);
-  int  tr = lua_type(L, 3);
-  int max_s = luaL_optint(L, 4, srcl+1);
-  int anchor = (*p == '^') ? (p++, 1) : 0;
-  int n = 0;
-  MatchState ms;
-  luaL_Buffer b;
-  luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
-                   tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
-                      "string/function/table expected");
-  luaL_buffinit(L, &b);
-  ms.L = L;
-  ms.src_init = src;
-  ms.src_end = src+srcl;
-  while (n < max_s) {
-    const char *e;
-    ms.level = 0;
-    e = match(&ms, src, p);
-    if (e) {
-      n++;
-      add_value(&ms, &b, src, e);
-    }
-    if (e && e>src) /* non empty match? */
-      src = e;  /* skip it */
-    else if (src < ms.src_end)
-      luaL_addchar(&b, *src++);
-    else break;
-    if (anchor) break;
-  }
-  luaL_addlstring(&b, src, ms.src_end-src);
-  luaL_pushresult(&b);
-  lua_pushinteger(L, n);  /* number of substitutions */
-  return 2;
-}
-
-/* }====================================================== */
-
-
-/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
-#define MAX_ITEM       512
-/* valid flags in a format specification */
-#define FLAGS  "-+ #0"
-/*
-** maximum size of each format specification (such as '%-099.99d')
-** (+10 accounts for %99.99x plus margin of error)
-*/
-#define MAX_FORMAT     (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
-
-
-static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
-  size_t l;
-  const char *s = luaL_checklstring(L, arg, &l);
-  luaL_addchar(b, '"');
-  while (l--) {
-    switch (*s) {
-      case '"': case '\\': case '\n': {
-        luaL_addchar(b, '\\');
-        luaL_addchar(b, *s);
-        break;
-      }
-      case '\r': {
-        luaL_addlstring(b, "\\r", 2);
-        break;
-      }
-      case '\0': {
-        luaL_addlstring(b, "\\000", 4);
-        break;
-      }
-      default: {
-        luaL_addchar(b, *s);
-        break;
-      }
-    }
-    s++;
-  }
-  luaL_addchar(b, '"');
-}
-
-static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
-  const char *p = strfrmt;
-  while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++;  /* skip flags */
-  if ((size_t)(p - strfrmt) >= sizeof(FLAGS))
-    luaL_error(L, "invalid format (repeated flags)");
-  if (isdigit(uchar(*p))) p++;  /* skip width */
-  if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
-  if (*p == '.') {
-    p++;
-    if (isdigit(uchar(*p))) p++;  /* skip precision */
-    if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
-  }
-  if (isdigit(uchar(*p)))
-    luaL_error(L, "invalid format (width or precision too long)");
-  *(form++) = '%';
-  strncpy(form, strfrmt, p - strfrmt + 1);
-  form += p - strfrmt + 1;
-  *form = '\0';
-  return p;
-}
-
-
-static void addintlen (char *form) {
-  size_t l = strlen(form);
-  char spec = form[l - 1];
-  strcpy(form + l - 1, LUA_INTFRMLEN);
-  form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;
-  form[l + sizeof(LUA_INTFRMLEN) - 1] = '\0';
-}
-
-
-static int str_format (lua_State *L) {
-  int arg = 1;
-  size_t sfl;
-  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
-  const char *strfrmt_end = strfrmt+sfl;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while (strfrmt < strfrmt_end) {
-    if (*strfrmt != L_ESC)
-      luaL_addchar(&b, *strfrmt++);
-    else if (*++strfrmt == L_ESC)
-      luaL_addchar(&b, *strfrmt++);  /* %% */
-    else { /* format item */
-      char form[MAX_FORMAT];  /* to store the format (`%...') */
-      char buff[MAX_ITEM];  /* to store the formatted item */
-      arg++;
-      strfrmt = scanformat(L, strfrmt, form);
-      switch (*strfrmt++) {
-        case 'c': {
-          sprintf(buff, form, (int)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'd':  case 'i': {
-          addintlen(form);
-          sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'o':  case 'u':  case 'x':  case 'X': {
-          addintlen(form);
-          sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'e':  case 'E': case 'f':
-        case 'g': case 'G': {
-          sprintf(buff, form, (double)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'q': {
-          addquoted(L, &b, arg);
-          continue;  /* skip the 'addsize' at the end */
-        }
-        case 's': {
-          size_t l;
-          const char *s = luaL_checklstring(L, arg, &l);
-          if (!strchr(form, '.') && l >= 100) {
-            /* no precision and string is too long to be formatted;
-               keep original string */
-            lua_pushvalue(L, arg);
-            luaL_addvalue(&b);
-            continue;  /* skip the `addsize' at the end */
-          }
-          else {
-            sprintf(buff, form, s);
-            break;
-          }
-        }
-        default: {  /* also treat cases `pnLlh' */
-          return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
-                               LUA_QL("format"), *(strfrmt - 1));
-        }
-      }
-      luaL_addlstring(&b, buff, strlen(buff));
-    }
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static const luaL_Reg strlib[] = {
-  {"byte", str_byte},
-  {"char", str_char},
-  {"dump", str_dump},
-  {"find", str_find},
-  {"format", str_format},
-  {"gfind", gfind_nodef},
-  {"gmatch", gmatch},
-  {"gsub", str_gsub},
-  {"len", str_len},
-  {"lower", str_lower},
-  {"match", str_match},
-  {"rep", str_rep},
-  {"reverse", str_reverse},
-  {"sub", str_sub},
-  {"upper", str_upper},
-  {NULL, NULL}
-};
-
-
-static void createmetatable (lua_State *L) {
-  lua_createtable(L, 0, 1);  /* create metatable for strings */
-  lua_pushliteral(L, "");  /* dummy string */
-  lua_pushvalue(L, -2);
-  lua_setmetatable(L, -2);  /* set string metatable */
-  lua_pop(L, 1);  /* pop dummy string */
-  lua_pushvalue(L, -2);  /* string library... */
-  lua_setfield(L, -2, "__index");  /* ...is the __index metamethod */
-  lua_pop(L, 1);  /* pop metatable */
-}
-
-
-/*
-** Open string library
-*/
-LUALIB_API int luaopen_string (lua_State *L) {
-  luaL_register(L, LUA_STRLIBNAME, strlib);
-#if defined(LUA_COMPAT_GFIND)
-  lua_getfield(L, -1, "gmatch");
-  lua_setfield(L, -2, "gfind");
-#endif
-  createmetatable(L);
-  return 1;
-}

diff --git a/source3/lua-5.1.4/src/ltable.c b/source3/lua-5.1.4/src/ltable.c
deleted file mode 100644 (file)
index 677b0e9..0000000
--- a/source3/lua-5.1.4/src/ltable.c
+++ /dev/null
@@ -1,588 +0,0 @@
-/*
-** $Id: ltable.c,v 2.32.1.2 2007/12/28 15:32:23 roberto Exp $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-
-/*
-** Implementation of tables (aka arrays, objects, or hash tables).
-** Tables keep its elements in two parts: an array part and a hash part.
-** Non-negative integer keys are all candidates to be kept in the array
-** part. The actual size of the array is the largest `n' such that at
-** least half the slots between 0 and n are in use.
-** Hash uses a mix of chained scatter table with Brent's variation.
-** A main invariant of these tables is that, if an element is not
-** in its main position (i.e. the `original' position that its hash gives
-** to it), then the colliding element is in its own main position.
-** Hence even when the load factor reaches 100%, performance remains good.
-*/
-
-#include <math.h>
-#include <string.h>
-
-#define ltable_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "ltable.h"
-
-
-/*
-** max size of array part is 2^MAXBITS
-*/
-#if LUAI_BITSINT > 26
-#define MAXBITS                26
-#else
-#define MAXBITS                (LUAI_BITSINT-2)
-#endif
-
-#define MAXASIZE       (1 << MAXBITS)
-
-
-#define hashpow2(t,n)      (gnode(t, lmod((n), sizenode(t))))
-
-#define hashstr(t,str)  hashpow2(t, (str)->tsv.hash)
-#define hashboolean(t,p)        hashpow2(t, p)
-
-
-/*
-** for some types, it is better to avoid modulus by power of 2, as
-** they tend to have many 2 factors.
-*/
-#define hashmod(t,n)   (gnode(t, ((n) % ((sizenode(t)-1)|1))))
-
-
-#define hashpointer(t,p)       hashmod(t, IntPoint(p))
-
-
-/*
-** number of ints inside a lua_Number
-*/
-#define numints                cast_int(sizeof(lua_Number)/sizeof(int))
-
-
-
-#define dummynode              (&dummynode_)
-
-static const Node dummynode_ = {
-  {{NULL}, LUA_TNIL},  /* value */
-  {{{NULL}, LUA_TNIL, NULL}}  /* key */
-};
-
-
-/*
-** hash for lua_Numbers
-*/
-static Node *hashnum (const Table *t, lua_Number n) {
-  unsigned int a[numints];
-  int i;
-  if (luai_numeq(n, 0))  /* avoid problems with -0 */
-    return gnode(t, 0);
-  memcpy(a, &n, sizeof(a));
-  for (i = 1; i < numints; i++) a[0] += a[i];
-  return hashmod(t, a[0]);
-}
-
-
-
-/*
-** returns the `main' position of an element in a table (that is, the index
-** of its hash value)
-*/
-static Node *mainposition (const Table *t, const TValue *key) {
-  switch (ttype(key)) {
-    case LUA_TNUMBER:
-      return hashnum(t, nvalue(key));
-    case LUA_TSTRING:
-      return hashstr(t, rawtsvalue(key));
-    case LUA_TBOOLEAN:
-      return hashboolean(t, bvalue(key));
-    case LUA_TLIGHTUSERDATA:
-      return hashpointer(t, pvalue(key));
-    default:
-      return hashpointer(t, gcvalue(key));
-  }
-}
-
-
-/*
-** returns the index for `key' if `key' is an appropriate key to live in
-** the array part of the table, -1 otherwise.
-*/
-static int arrayindex (const TValue *key) {
-  if (ttisnumber(key)) {
-    lua_Number n = nvalue(key);
-    int k;
-    lua_number2int(k, n);
-    if (luai_numeq(cast_num(k), n))
-      return k;
-  }
-  return -1;  /* `key' did not match some condition */
-}
-
-
-/*
-** returns the index of a `key' for table traversals. First goes all
-** elements in the array part, then elements in the hash part. The
-** beginning of a traversal is signalled by -1.
-*/
-static int findindex (lua_State *L, Table *t, StkId key) {
-  int i;
-  if (ttisnil(key)) return -1;  /* first iteration */
-  i = arrayindex(key);
-  if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
-    return i-1;  /* yes; that's the index (corrected to C) */
-  else {
-    Node *n = mainposition(t, key);
-    do {  /* check whether `key' is somewhere in the chain */
-      /* key may be dead already, but it is ok to use it in `next' */
-      if (luaO_rawequalObj(key2tval(n), key) ||
-            (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
-             gcvalue(gkey(n)) == gcvalue(key))) {
-        i = cast_int(n - gnode(t, 0));  /* key index in hash table */
-        /* hash elements are numbered after array ones */
-        return i + t->sizearray;
-      }
-      else n = gnext(n);
-    } while (n);
-    luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
-    return 0;  /* to avoid warnings */
-  }
-}
-
-
-int luaH_next (lua_State *L, Table *t, StkId key) {
-  int i = findindex(L, t, key);  /* find original element */
-  for (i++; i < t->sizearray; i++) {  /* try first array part */
-    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
-      setnvalue(key, cast_num(i+1));
-      setobj2s(L, key+1, &t->array[i]);
-      return 1;
-    }
-  }
-  for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */
-    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
-      setobj2s(L, key, key2tval(gnode(t, i)));
-      setobj2s(L, key+1, gval(gnode(t, i)));
-      return 1;
-    }
-  }
-  return 0;  /* no more elements */
-}
-
-
-/*
-** {=============================================================
-** Rehash
-** ==============================================================
-*/
-
-
-static int computesizes (int nums[], int *narray) {
-  int i;
-  int twotoi;  /* 2^i */
-  int a = 0;  /* number of elements smaller than 2^i */
-  int na = 0;  /* number of elements to go to array part */
-  int n = 0;  /* optimal size for array part */
-  for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {
-    if (nums[i] > 0) {
-      a += nums[i];
-      if (a > twotoi/2) {  /* more than half elements present? */
-        n = twotoi;  /* optimal size (till now) */
-        na = a;  /* all elements smaller than n will go to array part */
-      }
-    }
-    if (a == *narray) break;  /* all elements already counted */
-  }
-  *narray = n;
-  lua_assert(*narray/2 <= na && na <= *narray);
-  return na;
-}
-
-
-static int countint (const TValue *key, int *nums) {
-  int k = arrayindex(key);
-  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
-    nums[ceillog2(k)]++;  /* count as such */
-    return 1;
-  }
-  else
-    return 0;
-}
-
-
-static int numusearray (const Table *t, int *nums) {
-  int lg;
-  int ttlg;  /* 2^lg */
-  int ause = 0;  /* summation of `nums' */
-  int i = 1;  /* count to traverse all array keys */
-  for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) {  /* for each slice */
-    int lc = 0;  /* counter */
-    int lim = ttlg;
-    if (lim > t->sizearray) {
-      lim = t->sizearray;  /* adjust upper limit */
-      if (i > lim)
-        break;  /* no more elements to count */
-    }
-    /* count elements in range (2^(lg-1), 2^lg] */
-    for (; i <= lim; i++) {
-      if (!ttisnil(&t->array[i-1]))
-        lc++;
-    }
-    nums[lg] += lc;
-    ause += lc;
-  }
-  return ause;
-}
-
-
-static int numusehash (const Table *t, int *nums, int *pnasize) {
-  int totaluse = 0;  /* total number of elements */
-  int ause = 0;  /* summation of `nums' */
-  int i = sizenode(t);
-  while (i--) {
-    Node *n = &t->node[i];
-    if (!ttisnil(gval(n))) {
-      ause += countint(key2tval(n), nums);
-      totaluse++;
-    }
-  }
-  *pnasize += ause;
-  return totaluse;
-}
-
-
-static void setarrayvector (lua_State *L, Table *t, int size) {
-  int i;
-  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
-  for (i=t->sizearray; i<size; i++)
-     setnilvalue(&t->array[i]);
-  t->sizearray = size;
-}
-
-
-static void setnodevector (lua_State *L, Table *t, int size) {
-  int lsize;
-  if (size == 0) {  /* no elements to hash part? */
-    t->node = cast(Node *, dummynode);  /* use common `dummynode' */
-    lsize = 0;
-  }
-  else {
-    int i;
-    lsize = ceillog2(size);
-    if (lsize > MAXBITS)
-      luaG_runerror(L, "table overflow");
-    size = twoto(lsize);
-    t->node = luaM_newvector(L, size, Node);
-    for (i=0; i<size; i++) {
-      Node *n = gnode(t, i);
-      gnext(n) = NULL;
-      setnilvalue(gkey(n));
-      setnilvalue(gval(n));
-    }
-  }
-  t->lsizenode = cast_byte(lsize);
-  t->lastfree = gnode(t, size);  /* all positions are free */
-}
-
-
-static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
-  int i;
-  int oldasize = t->sizearray;
-  int oldhsize = t->lsizenode;
-  Node *nold = t->node;  /* save old hash ... */
-  if (nasize > oldasize)  /* array part must grow? */
-    setarrayvector(L, t, nasize);
-  /* create new hash part with appropriate size */
-  setnodevector(L, t, nhsize);
-  if (nasize < oldasize) {  /* array part must shrink? */
-    t->sizearray = nasize;
-    /* re-insert elements from vanishing slice */
-    for (i=nasize; i<oldasize; i++) {
-      if (!ttisnil(&t->array[i]))
-        setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);
-    }
-    /* shrink array */
-    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
-  }
-  /* re-insert elements from hash part */
-  for (i = twoto(oldhsize) - 1; i >= 0; i--) {
-    Node *old = nold+i;
-    if (!ttisnil(gval(old)))
-      setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
-  }
-  if (nold != dummynode)
-    luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
-}
-
-
-void luaH_resizearray (lua_State *L, Table *t, int nasize) {
-  int nsize = (t->node == dummynode) ? 0 : sizenode(t);
-  resize(L, t, nasize, nsize);
-}
-
-
-static void rehash (lua_State *L, Table *t, const TValue *ek) {
-  int nasize, na;
-  int nums[MAXBITS+1];  /* nums[i] = number of keys between 2^(i-1) and 2^i */
-  int i;
-  int totaluse;
-  for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */
-  nasize = numusearray(t, nums);  /* count keys in array part */
-  totaluse = nasize;  /* all those keys are integer keys */
-  totaluse += numusehash(t, nums, &nasize);  /* count keys in hash part */
-  /* count extra key */
-  nasize += countint(ek, nums);
-  totaluse++;
-  /* compute new size for array part */
-  na = computesizes(nums, &nasize);
-  /* resize the table to new computed sizes */
-  resize(L, t, nasize, totaluse - na);
-}
-
-
-
-/*
-** }=============================================================
-*/
-
-
-Table *luaH_new (lua_State *L, int narray, int nhash) {
-  Table *t = luaM_new(L, Table);
-  luaC_link(L, obj2gco(t), LUA_TTABLE);
-  t->metatable = NULL;
-  t->flags = cast_byte(~0);
-  /* temporary values (kept only if some malloc fails) */
-  t->array = NULL;
-  t->sizearray = 0;
-  t->lsizenode = 0;
-  t->node = cast(Node *, dummynode);
-  setarrayvector(L, t, narray);
-  setnodevector(L, t, nhash);
-  return t;
-}
-
-
-void luaH_free (lua_State *L, Table *t) {
-  if (t->node != dummynode)
-    luaM_freearray(L, t->node, sizenode(t), Node);
-  luaM_freearray(L, t->array, t->sizearray, TValue);
-  luaM_free(L, t);
-}
-
-
-static Node *getfreepos (Table *t) {
-  while (t->lastfree-- > t->node) {
-    if (ttisnil(gkey(t->lastfree)))
-      return t->lastfree;
-  }
-  return NULL;  /* could not find a free place */
-}
-
-
-
-/*
-** inserts a new key into a hash table; first, check whether key's main
-** position is free. If not, check whether colliding node is in its main
-** position or not: if it is not, move colliding node to an empty place and
-** put new key in its main position; otherwise (colliding node is in its main
-** position), new key goes to an empty position.
-*/
-static TValue *newkey (lua_State *L, Table *t, const TValue *key) {
-  Node *mp = mainposition(t, key);
-  if (!ttisnil(gval(mp)) || mp == dummynode) {
-    Node *othern;
-    Node *n = getfreepos(t);  /* get a free place */
-    if (n == NULL) {  /* cannot find a free place? */
-      rehash(L, t, key);  /* grow table */
-      return luaH_set(L, t, key);  /* re-insert key into grown table */
-    }
-    lua_assert(n != dummynode);
-    othern = mainposition(t, key2tval(mp));
-    if (othern != mp) {  /* is colliding node out of its main position? */
-      /* yes; move colliding node into free position */
-      while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */
-      gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */
-      *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
-      gnext(mp) = NULL;  /* now `mp' is free */
-      setnilvalue(gval(mp));
-    }
-    else {  /* colliding node is in its own main position */
-      /* new node will go into free position */
-      gnext(n) = gnext(mp);  /* chain new position */
-      gnext(mp) = n;
-      mp = n;
-    }
-  }
-  gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;
-  luaC_barriert(L, t, key);
-  lua_assert(ttisnil(gval(mp)));
-  return gval(mp);
-}
-
-
-/*
-** search function for integers
-*/
-const TValue *luaH_getnum (Table *t, int key) {
-  /* (1 <= key && key <= t->sizearray) */
-  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
-    return &t->array[key-1];
-  else {
-    lua_Number nk = cast_num(key);
-    Node *n = hashnum(t, nk);
-    do {  /* check whether `key' is somewhere in the chain */
-      if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
-        return gval(n);  /* that's it */
-      else n = gnext(n);
-    } while (n);
-    return luaO_nilobject;
-  }
-}
-
-
-/*
-** search function for strings
-*/
-const TValue *luaH_getstr (Table *t, TString *key) {
-  Node *n = hashstr(t, key);
-  do {  /* check whether `key' is somewhere in the chain */
-    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
-      return gval(n);  /* that's it */
-    else n = gnext(n);
-  } while (n);
-  return luaO_nilobject;
-}
-
-
-/*
-** main search function
-*/
-const TValue *luaH_get (Table *t, const TValue *key) {
-  switch (ttype(key)) {
-    case LUA_TNIL: return luaO_nilobject;
-    case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
-    case LUA_TNUMBER: {
-      int k;
-      lua_Number n = nvalue(key);
-      lua_number2int(k, n);
-      if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
-        return luaH_getnum(t, k);  /* use specialized version */
-      /* else go through */
-    }
-    default: {
-      Node *n = mainposition(t, key);
-      do {  /* check whether `key' is somewhere in the chain */
-        if (luaO_rawequalObj(key2tval(n), key))
-          return gval(n);  /* that's it */
-        else n = gnext(n);
-      } while (n);
-      return luaO_nilobject;
-    }
-  }
-}
-
-
-TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
-  const TValue *p = luaH_get(t, key);
-  t->flags = 0;
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
-    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
-      luaG_runerror(L, "table index is NaN");
-    return newkey(L, t, key);
-  }
-}
-
-
-TValue *luaH_setnum (lua_State *L, Table *t, int key) {
-  const TValue *p = luaH_getnum(t, key);
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    TValue k;
-    setnvalue(&k, cast_num(key));
-    return newkey(L, t, &k);
-  }
-}
-
-
-TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
-  const TValue *p = luaH_getstr(t, key);
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    TValue k;
-    setsvalue(L, &k, key);
-    return newkey(L, t, &k);
-  }
-}
-
-
-static int unbound_search (Table *t, unsigned int j) {
-  unsigned int i = j;  /* i is zero or a present index */
-  j++;
-  /* find `i' and `j' such that i is present and j is not */
-  while (!ttisnil(luaH_getnum(t, j))) {
-    i = j;
-    j *= 2;
-    if (j > cast(unsigned int, MAX_INT)) {  /* overflow? */
-      /* table was built with bad purposes: resort to linear search */
-      i = 1;
-      while (!ttisnil(luaH_getnum(t, i))) i++;
-      return i - 1;
-    }
-  }
-  /* now do a binary search between them */
-  while (j - i > 1) {
-    unsigned int m = (i+j)/2;
-    if (ttisnil(luaH_getnum(t, m))) j = m;
-    else i = m;
-  }
-  return i;
-}
-
-
-/*
-** Try to find a boundary in table `t'. A `boundary' is an integer index
-** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
-*/
-int luaH_getn (Table *t) {
-  unsigned int j = t->sizearray;
-  if (j > 0 && ttisnil(&t->array[j - 1])) {
-    /* there is a boundary in the array part: (binary) search for it */
-    unsigned int i = 0;
-    while (j - i > 1) {
-      unsigned int m = (i+j)/2;
-      if (ttisnil(&t->array[m - 1])) j = m;
-      else i = m;
-    }
-    return i;
-  }
-  /* else must find a boundary in hash part */
-  else if (t->node == dummynode)  /* hash part is empty? */
-    return j;  /* that is easy... */
-  else return unbound_search(t, j);
-}
-
-
-
-#if defined(LUA_DEBUG)
-
-Node *luaH_mainposition (const Table *t, const TValue *key) {
-  return mainposition(t, key);
-}
-
-int luaH_isdummy (Node *n) { return n == dummynode; }
-
-#endif

diff --git a/source3/lua-5.1.4/src/ltable.h b/source3/lua-5.1.4/src/ltable.h
deleted file mode 100644 (file)
index f5b9d5e..0000000
--- a/source3/lua-5.1.4/src/ltable.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-** $Id: ltable.h,v 2.10.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ltable_h
-#define ltable_h
-
-#include "lobject.h"
-
-
-#define gnode(t,i)     (&(t)->node[i])
-#define gkey(n)                (&(n)->i_key.nk)
-#define gval(n)                (&(n)->i_val)
-#define gnext(n)       ((n)->i_key.nk.next)
-
-#define key2tval(n)    (&(n)->i_key.tvk)
-
-
-LUAI_FUNC const TValue *luaH_getnum (Table *t, int key);
-LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key);
-LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
-LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);
-LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
-LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
-LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash);
-LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
-LUAI_FUNC void luaH_free (lua_State *L, Table *t);
-LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
-LUAI_FUNC int luaH_getn (Table *t);
-
-
-#if defined(LUA_DEBUG)
-LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
-LUAI_FUNC int luaH_isdummy (Node *n);
-#endif
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/ltablib.c b/source3/lua-5.1.4/src/ltablib.c
deleted file mode 100644 (file)
index 2e50ce0..0000000
--- a/source3/lua-5.1.4/src/ltablib.c
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
-** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $
-** Library for Table Manipulation
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define ltablib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#define aux_getn(L,n)  (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))
-
-
-static int foreachi (lua_State *L) {
-  int i;
-  int n = aux_getn(L, 1);
-  luaL_checktype(L, 2, LUA_TFUNCTION);
-  for (i=1; i <= n; i++) {
-    lua_pushvalue(L, 2);  /* function */
-    lua_pushinteger(L, i);  /* 1st argument */
-    lua_rawgeti(L, 1, i);  /* 2nd argument */
-    lua_call(L, 2, 1);
-    if (!lua_isnil(L, -1))
-      return 1;
-    lua_pop(L, 1);  /* remove nil result */
-  }
-  return 0;
-}
-
-
-static int foreach (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checktype(L, 2, LUA_TFUNCTION);
-  lua_pushnil(L);  /* first key */
-  while (lua_next(L, 1)) {
-    lua_pushvalue(L, 2);  /* function */
-    lua_pushvalue(L, -3);  /* key */
-    lua_pushvalue(L, -3);  /* value */
-    lua_call(L, 2, 1);
-    if (!lua_isnil(L, -1))
-      return 1;
-    lua_pop(L, 2);  /* remove value and result */
-  }
-  return 0;
-}
-
-
-static int maxn (lua_State *L) {
-  lua_Number max = 0;
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushnil(L);  /* first key */
-  while (lua_next(L, 1)) {
-    lua_pop(L, 1);  /* remove value */
-    if (lua_type(L, -1) == LUA_TNUMBER) {
-      lua_Number v = lua_tonumber(L, -1);
-      if (v > max) max = v;
-    }
-  }
-  lua_pushnumber(L, max);
-  return 1;
-}
-
-
-static int getn (lua_State *L) {
-  lua_pushinteger(L, aux_getn(L, 1));
-  return 1;
-}
-
-
-static int setn (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-#ifndef luaL_setn
-  luaL_setn(L, 1, luaL_checkint(L, 2));
-#else
-  luaL_error(L, LUA_QL("setn") " is obsolete");
-#endif
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-
-static int tinsert (lua_State *L) {
-  int e = aux_getn(L, 1) + 1;  /* first empty element */
-  int pos;  /* where to insert new element */
-  switch (lua_gettop(L)) {
-    case 2: {  /* called with only 2 arguments */
-      pos = e;  /* insert new element at the end */
-      break;
-    }
-    case 3: {
-      int i;
-      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
-      if (pos > e) e = pos;  /* `grow' array if necessary */
-      for (i = e; i > pos; i--) {  /* move up elements */
-        lua_rawgeti(L, 1, i-1);
-        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
-      }
-      break;
-    }
-    default: {
-      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
-    }
-  }
-  luaL_setn(L, 1, e);  /* new size */
-  lua_rawseti(L, 1, pos);  /* t[pos] = v */
-  return 0;
-}
-
-
-static int tremove (lua_State *L) {
-  int e = aux_getn(L, 1);
-  int pos = luaL_optint(L, 2, e);
-  if (!(1 <= pos && pos <= e))  /* position is outside bounds? */
-   return 0;  /* nothing to remove */
-  luaL_setn(L, 1, e - 1);  /* t.n = n-1 */
-  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
-  for ( ;pos<e; pos++) {
-    lua_rawgeti(L, 1, pos+1);
-    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
-  }
-  lua_pushnil(L);
-  lua_rawseti(L, 1, e);  /* t[e] = nil */
-  return 1;
-}
-
-
-static void addfield (lua_State *L, luaL_Buffer *b, int i) {
-  lua_rawgeti(L, 1, i);
-  if (!lua_isstring(L, -1))
-    luaL_error(L, "invalid value (%s) at index %d in table for "
-                  LUA_QL("concat"), luaL_typename(L, -1), i);
-    luaL_addvalue(b);
-}
-
-
-static int tconcat (lua_State *L) {
-  luaL_Buffer b;
-  size_t lsep;
-  int i, last;
-  const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i = luaL_optint(L, 3, 1);
-  last = luaL_opt(L, luaL_checkint, 4, luaL_getn(L, 1));
-  luaL_buffinit(L, &b);
-  for (; i < last; i++) {
-    addfield(L, &b, i);
-    luaL_addlstring(&b, sep, lsep);
-  }
-  if (i == last)  /* add last value (if interval was not empty) */
-    addfield(L, &b, i);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-
-/*
-** {======================================================
-** Quicksort
-** (based on `Algorithms in MODULA-3', Robert Sedgewick;
-**  Addison-Wesley, 1993.)
-*/
-
-
-static void set2 (lua_State *L, int i, int j) {
-  lua_rawseti(L, 1, i);
-  lua_rawseti(L, 1, j);
-}
-
-static int sort_comp (lua_State *L, int a, int b) {
-  if (!lua_isnil(L, 2)) {  /* function? */
-    int res;
-    lua_pushvalue(L, 2);
-    lua_pushvalue(L, a-1);  /* -1 to compensate function */
-    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
-    lua_call(L, 2, 1);
-    res = lua_toboolean(L, -1);
-    lua_pop(L, 1);
-    return res;
-  }
-  else  /* a < b? */
-    return lua_lessthan(L, a, b);
-}
-
-static void auxsort (lua_State *L, int l, int u) {
-  while (l < u) {  /* for tail recursion */
-    int i, j;
-    /* sort elements a[l], a[(l+u)/2] and a[u] */
-    lua_rawgeti(L, 1, l);
-    lua_rawgeti(L, 1, u);
-    if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
-      set2(L, l, u);  /* swap a[l] - a[u] */
-    else
-      lua_pop(L, 2);
-    if (u-l == 1) break;  /* only 2 elements */
-    i = (l+u)/2;
-    lua_rawgeti(L, 1, i);
-    lua_rawgeti(L, 1, l);
-    if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
-      set2(L, i, l);
-    else {
-      lua_pop(L, 1);  /* remove a[l] */
-      lua_rawgeti(L, 1, u);
-      if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
-        set2(L, i, u);
-      else
-        lua_pop(L, 2);
-    }
-    if (u-l == 2) break;  /* only 3 elements */
-    lua_rawgeti(L, 1, i);  /* Pivot */
-    lua_pushvalue(L, -1);
-    lua_rawgeti(L, 1, u-1);
-    set2(L, i, u-1);
-    /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
-    i = l; j = u-1;
-    for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
-      /* repeat ++i until a[i] >= P */
-      while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
-        if (i>u) luaL_error(L, "invalid order function for sorting");
-        lua_pop(L, 1);  /* remove a[i] */
-      }
-      /* repeat --j until a[j] <= P */
-      while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
-        if (j<l) luaL_error(L, "invalid order function for sorting");
-        lua_pop(L, 1);  /* remove a[j] */
-      }
-      if (j<i) {
-        lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
-        break;
-      }
-      set2(L, i, j);
-    }
-    lua_rawgeti(L, 1, u-1);
-    lua_rawgeti(L, 1, i);
-    set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
-    /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
-    /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
-    if (i-l < u-i) {
-      j=l; i=i-1; l=i+2;
-    }
-    else {
-      j=i+1; i=u; u=j-2;
-    }
-    auxsort(L, j, i);  /* call recursively the smaller one */
-  }  /* repeat the routine for the larger one */
-}
-
-static int sort (lua_State *L) {
-  int n = aux_getn(L, 1);
-  luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
-  if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
-    luaL_checktype(L, 2, LUA_TFUNCTION);
-  lua_settop(L, 2);  /* make sure there is two arguments */
-  auxsort(L, 1, n);
-  return 0;
-}
-
-/* }====================================================== */
-
-
-static const luaL_Reg tab_funcs[] = {
-  {"concat", tconcat},
-  {"foreach", foreach},
-  {"foreachi", foreachi},
-  {"getn", getn},
-  {"maxn", maxn},
-  {"insert", tinsert},
-  {"remove", tremove},
-  {"setn", setn},
-  {"sort", sort},
-  {NULL, NULL}
-};
-
-
-LUALIB_API int luaopen_table (lua_State *L) {
-  luaL_register(L, LUA_TABLIBNAME, tab_funcs);
-  return 1;
-}

diff --git a/source3/lua-5.1.4/src/ltm.c b/source3/lua-5.1.4/src/ltm.c
deleted file mode 100644 (file)
index 1612f3c..0000000
--- a/source3/lua-5.1.4/src/ltm.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-** $Id: ltm.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define ltm_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-
-const char *const luaT_typenames[] = {
-  "nil", "boolean", "userdata", "number",
-  "string", "table", "function", "userdata", "thread",
-  "proto", "upval"
-};
-
-
-void luaT_init (lua_State *L) {
-  static const char *const luaT_eventname[] = {  /* ORDER TM */
-    "__index", "__newindex",
-    "__gc", "__mode", "__eq",
-    "__add", "__sub", "__mul", "__div", "__mod",
-    "__pow", "__unm", "__len", "__lt", "__le",
-    "__concat", "__call"
-  };
-  int i;
-  for (i=0; i<TM_N; i++) {
-    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
-    luaS_fix(G(L)->tmname[i]);  /* never collect these names */
-  }
-}
-
-
-/*
-** function to be used with macro "fasttm": optimized for absence of
-** tag methods
-*/
-const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
-  const TValue *tm = luaH_getstr(events, ename);
-  lua_assert(event <= TM_EQ);
-  if (ttisnil(tm)) {  /* no tag method? */
-    events->flags |= cast_byte(1u<<event);  /* cache this fact */
-    return NULL;
-  }
-  else return tm;
-}
-
-
-const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
-  Table *mt;
-  switch (ttype(o)) {
-    case LUA_TTABLE:
-      mt = hvalue(o)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(o)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttype(o)];
-  }
-  return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
-}

diff --git a/source3/lua-5.1.4/src/ltm.h b/source3/lua-5.1.4/src/ltm.h
deleted file mode 100644 (file)
index 64343b7..0000000
--- a/source3/lua-5.1.4/src/ltm.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-** $Id: ltm.h,v 2.6.1.1 2007/12/27 13:02:25 roberto Exp $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ltm_h
-#define ltm_h
-
-
-#include "lobject.h"
-
-
-/*
-* WARNING: if you change the order of this enumeration,
-* grep "ORDER TM"
-*/
-typedef enum {
-  TM_INDEX,
-  TM_NEWINDEX,
-  TM_GC,
-  TM_MODE,
-  TM_EQ,  /* last tag method with `fast' access */
-  TM_ADD,
-  TM_SUB,
-  TM_MUL,
-  TM_DIV,
-  TM_MOD,
-  TM_POW,
-  TM_UNM,
-  TM_LEN,
-  TM_LT,
-  TM_LE,
-  TM_CONCAT,
-  TM_CALL,
-  TM_N         /* number of elements in the enum */
-} TMS;
-
-
-
-#define gfasttm(g,et,e) ((et) == NULL ? NULL : \
-  ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
-
-#define fasttm(l,et,e) gfasttm(G(l), et, e)
-
-LUAI_DATA const char *const luaT_typenames[];
-
-
-LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
-LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
-                                                       TMS event);
-LUAI_FUNC void luaT_init (lua_State *L);
-
-#endif

diff --git a/source3/lua-5.1.4/src/lua.c b/source3/lua-5.1.4/src/lua.c
deleted file mode 100644 (file)
index f591375..0000000
--- a/source3/lua-5.1.4/src/lua.c
+++ /dev/null
@@ -1,391 +0,0 @@
-/*
-** $Id: lua.c,v 1.160.1.2 2007/12/28 15:32:23 roberto Exp $
-** Lua stand-alone interpreter
-** See Copyright Notice in lua.h
-*/
-
-
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lua_c
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-static lua_State *globalL = NULL;
-
-static const char *progname = LUA_PROGNAME;
-
-
-
-static void lstop (lua_State *L, lua_Debug *ar) {
-  (void)ar;  /* unused arg. */
-  lua_sethook(L, NULL, 0, 0);
-  luaL_error(L, "interrupted!");
-}
-
-
-static void laction (int i) {
-  signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
-                              terminate process (default action) */
-  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
-}
-
-
-static void print_usage (void) {
-  fprintf(stderr,
-  "usage: %s [options] [script [args]].\n"
-  "Available options are:\n"
-  "  -e stat  execute string " LUA_QL("stat") "\n"
-  "  -l name  require library " LUA_QL("name") "\n"
-  "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
-  "  -v       show version information\n"
-  "  --       stop handling options\n"
-  "  -        execute stdin and stop handling options\n"
-  ,
-  progname);
-  fflush(stderr);
-}
-
-
-static void l_message (const char *pname, const char *msg) {
-  if (pname) fprintf(stderr, "%s: ", pname);
-  fprintf(stderr, "%s\n", msg);
-  fflush(stderr);
-}
-
-
-static int report (lua_State *L, int status) {
-  if (status && !lua_isnil(L, -1)) {
-    const char *msg = lua_tostring(L, -1);
-    if (msg == NULL) msg = "(error object is not a string)";
-    l_message(progname, msg);
-    lua_pop(L, 1);
-  }
-  return status;
-}
-
-
-static int traceback (lua_State *L) {
-  if (!lua_isstring(L, 1))  /* 'message' not a string? */
-    return 1;  /* keep it intact */
-  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
-  if (!lua_istable(L, -1)) {
-    lua_pop(L, 1);
-    return 1;
-  }
-  lua_getfield(L, -1, "traceback");
-  if (!lua_isfunction(L, -1)) {
-    lua_pop(L, 2);
-    return 1;
-  }
-  lua_pushvalue(L, 1);  /* pass error message */
-  lua_pushinteger(L, 2);  /* skip this function and traceback */
-  lua_call(L, 2, 1);  /* call debug.traceback */
-  return 1;
-}
-
-
-static int docall (lua_State *L, int narg, int clear) {
-  int status;
-  int base = lua_gettop(L) - narg;  /* function index */
-  lua_pushcfunction(L, traceback);  /* push traceback function */
-  lua_insert(L, base);  /* put it under chunk and args */
-  signal(SIGINT, laction);
-  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
-  signal(SIGINT, SIG_DFL);
-  lua_remove(L, base);  /* remove traceback function */
-  /* force a complete garbage collection in case of errors */
-  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
-  return status;
-}
-
-
-static void print_version (void) {
-  l_message(NULL, LUA_RELEASE "  " LUA_COPYRIGHT);
-}
-
-
-static int getargs (lua_State *L, char **argv, int n) {
-  int narg;
-  int i;
-  int argc = 0;
-  while (argv[argc]) argc++;  /* count total number of arguments */
-  narg = argc - (n + 1);  /* number of arguments to the script */
-  luaL_checkstack(L, narg + 3, "too many arguments to script");
-  for (i=n+1; i < argc; i++)
-    lua_pushstring(L, argv[i]);
-  lua_createtable(L, narg, n + 1);
-  for (i=0; i < argc; i++) {
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i - n);
-  }
-  return narg;
-}
-
-
-static int dofile (lua_State *L, const char *name) {
-  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
-  return report(L, status);
-}
-
-
-static int dostring (lua_State *L, const char *s, const char *name) {
-  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
-  return report(L, status);
-}
-
-
-static int dolibrary (lua_State *L, const char *name) {
-  lua_getglobal(L, "require");
-  lua_pushstring(L, name);
-  return report(L, docall(L, 1, 1));
-}
-
-
-static const char *get_prompt (lua_State *L, int firstline) {
-  const char *p;
-  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
-  p = lua_tostring(L, -1);
-  if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
-  lua_pop(L, 1);  /* remove global */
-  return p;
-}
-
-
-static int incomplete (lua_State *L, int status) {
-  if (status == LUA_ERRSYNTAX) {
-    size_t lmsg;
-    const char *msg = lua_tolstring(L, -1, &lmsg);
-    const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
-    if (strstr(msg, LUA_QL("<eof>")) == tp) {
-      lua_pop(L, 1);
-      return 1;
-    }
-  }
-  return 0;  /* else... */
-}
-
-
-static int pushline (lua_State *L, int firstline) {
-  char buffer[LUA_MAXINPUT];
-  char *b = buffer;
-  size_t l;
-  const char *prmt = get_prompt(L, firstline);
-  if (lua_readline(L, b, prmt) == 0)
-    return 0;  /* no input */
-  l = strlen(b);
-  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
-    b[l-1] = '\0';  /* remove it */
-  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
-    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
-  else
-    lua_pushstring(L, b);
-  lua_freeline(L, b);
-  return 1;
-}
-
-
-static int loadline (lua_State *L) {
-  int status;
-  lua_settop(L, 0);
-  if (!pushline(L, 1))
-    return -1;  /* no input */
-  for (;;) {  /* repeat until gets a complete line */
-    status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
-    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
-    if (!pushline(L, 0))  /* no more input? */
-      return -1;
-    lua_pushliteral(L, "\n");  /* add a new line... */
-    lua_insert(L, -2);  /* ...between the two lines */
-    lua_concat(L, 3);  /* join them */
-  }
-  lua_saveline(L, 1);
-  lua_remove(L, 1);  /* remove line */
-  return status;
-}
-
-
-static void dotty (lua_State *L) {
-  int status;
-  const char *oldprogname = progname;
-  progname = NULL;
-  while ((status = loadline(L)) != -1) {
-    if (status == 0) status = docall(L, 0, 0);
-    report(L, status);
-    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
-      lua_getglobal(L, "print");
-      lua_insert(L, 1);
-      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
-        l_message(progname, lua_pushfstring(L,
-                               "error calling " LUA_QL("print") " (%s)",
-                               lua_tostring(L, -1)));
-    }
-  }
-  lua_settop(L, 0);  /* clear stack */
-  fputs("\n", stdout);
-  fflush(stdout);
-  progname = oldprogname;
-}
-
-
-static int handle_script (lua_State *L, char **argv, int n) {
-  int status;
-  const char *fname;
-  int narg = getargs(L, argv, n);  /* collect arguments */
-  lua_setglobal(L, "arg");
-  fname = argv[n];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0)
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  lua_insert(L, -(narg+1));
-  if (status == 0)
-    status = docall(L, narg, 0);
-  else
-    lua_pop(L, narg);
-  return report(L, status);
-}
-
-
-/* check that argument has no extra characters at the end */
-#define notail(x)      {if ((x)[2] != '\0') return -1;}
-
-
-static int collectargs (char **argv, int *pi, int *pv, int *pe) {
-  int i;
-  for (i = 1; argv[i] != NULL; i++) {
-    if (argv[i][0] != '-')  /* not an option? */
-        return i;
-    switch (argv[i][1]) {  /* option */
-      case '-':
-        notail(argv[i]);
-        return (argv[i+1] != NULL ? i+1 : 0);
-      case '\0':
-        return i;
-      case 'i':
-        notail(argv[i]);
-        *pi = 1;  /* go through */
-      case 'v':
-        notail(argv[i]);
-        *pv = 1;
-        break;
-      case 'e':
-        *pe = 1;  /* go through */
-      case 'l':
-        if (argv[i][2] == '\0') {
-          i++;
-          if (argv[i] == NULL) return -1;
-        }
-        break;
-      default: return -1;  /* invalid option */
-    }
-  }
-  return 0;
-}
-
-
-static int runargs (lua_State *L, char **argv, int n) {
-  int i;
-  for (i = 1; i < n; i++) {
-    if (argv[i] == NULL) continue;
-    lua_assert(argv[i][0] == '-');
-    switch (argv[i][1]) {  /* option */
-      case 'e': {
-        const char *chunk = argv[i] + 2;
-        if (*chunk == '\0') chunk = argv[++i];
-        lua_assert(chunk != NULL);
-        if (dostring(L, chunk, "=(command line)") != 0)
-          return 1;
-        break;
-      }
-      case 'l': {
-        const char *filename = argv[i] + 2;
-        if (*filename == '\0') filename = argv[++i];
-        lua_assert(filename != NULL);
-        if (dolibrary(L, filename))
-          return 1;  /* stop if file fails */
-        break;
-      }
-      default: break;
-    }
-  }
-  return 0;
-}
-
-
-static int handle_luainit (lua_State *L) {
-  const char *init = getenv(LUA_INIT);
-  if (init == NULL) return 0;  /* status OK */
-  else if (init[0] == '@')
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, "=" LUA_INIT);
-}
-
-
-struct Smain {
-  int argc;
-  char **argv;
-  int status;
-};
-
-
-static int pmain (lua_State *L) {
-  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
-  char **argv = s->argv;
-  int script;
-  int has_i = 0, has_v = 0, has_e = 0;
-  globalL = L;
-  if (argv[0] && argv[0][0]) progname = argv[0];
-  lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
-  luaL_openlibs(L);  /* open libraries */
-  lua_gc(L, LUA_GCRESTART, 0);
-  s->status = handle_luainit(L);
-  if (s->status != 0) return 0;
-  script = collectargs(argv, &has_i, &has_v, &has_e);
-  if (script < 0) {  /* invalid args? */
-    print_usage();
-    s->status = 1;
-    return 0;
-  }
-  if (has_v) print_version();
-  s->status = runargs(L, argv, (script > 0) ? script : s->argc);
-  if (s->status != 0) return 0;
-  if (script)
-    s->status = handle_script(L, argv, script);
-  if (s->status != 0) return 0;
-  if (has_i)
-    dotty(L);
-  else if (script == 0 && !has_e && !has_v) {
-    if (lua_stdin_is_tty()) {
-      print_version();
-      dotty(L);
-    }
-    else dofile(L, NULL);  /* executes stdin as a file */
-  }
-  return 0;
-}
-
-
-int main (int argc, char **argv) {
-  int status;
-  struct Smain s;
-  lua_State *L = lua_open();  /* create state */
-  if (L == NULL) {
-    l_message(argv[0], "cannot create state: not enough memory");
-    return EXIT_FAILURE;
-  }
-  s.argc = argc;
-  s.argv = argv;
-  status = lua_cpcall(L, &pmain, &s);
-  report(L, status);
-  lua_close(L);
-  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
-}

diff --git a/source3/lua-5.1.4/src/lua.h b/source3/lua-5.1.4/src/lua.h
deleted file mode 100644 (file)
index b796878..0000000
--- a/source3/lua-5.1.4/src/lua.h
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
-** $Id: lua.h,v 1.218.1.5 2008/08/06 13:30:12 roberto Exp $
-** Lua - An Extensible Extension Language
-** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
-** See Copyright Notice at the end of this file
-*/
-
-
-#ifndef lua_h
-#define lua_h
-
-#include <stdarg.h>
-#include <stddef.h>
-
-
-#include "luaconf.h"
-
-
-#define LUA_VERSION    "Lua 5.1"
-#define LUA_RELEASE    "Lua 5.1.4"
-#define LUA_VERSION_NUM        501
-#define LUA_COPYRIGHT  "Copyright (C) 1994-2008 Lua.org, PUC-Rio"
-#define LUA_AUTHORS    "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
-
-
-/* mark for precompiled code (`<esc>Lua') */
-#define        LUA_SIGNATURE   "\033Lua"
-
-/* option for multiple returns in `lua_pcall' and `lua_call' */
-#define LUA_MULTRET    (-1)
-
-
-/*
-** pseudo-indices
-*/
-#define LUA_REGISTRYINDEX      (-10000)
-#define LUA_ENVIRONINDEX       (-10001)
-#define LUA_GLOBALSINDEX       (-10002)
-#define lua_upvalueindex(i)    (LUA_GLOBALSINDEX-(i))
-
-
-/* thread status; 0 is OK */
-#define LUA_YIELD      1
-#define LUA_ERRRUN     2
-#define LUA_ERRSYNTAX  3
-#define LUA_ERRMEM     4
-#define LUA_ERRERR     5
-
-
-typedef struct lua_State lua_State;
-
-typedef int (*lua_CFunction) (lua_State *L);
-
-
-/*
-** functions that read/write blocks when loading/dumping Lua chunks
-*/
-typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
-
-typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
-
-
-/*
-** prototype for memory-allocation functions
-*/
-typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
-
-
-/*
-** basic types
-*/
-#define LUA_TNONE              (-1)
-
-#define LUA_TNIL               0
-#define LUA_TBOOLEAN           1
-#define LUA_TLIGHTUSERDATA     2
-#define LUA_TNUMBER            3
-#define LUA_TSTRING            4
-#define LUA_TTABLE             5
-#define LUA_TFUNCTION          6
-#define LUA_TUSERDATA          7
-#define LUA_TTHREAD            8
-
-
-
-/* minimum Lua stack available to a C function */
-#define LUA_MINSTACK   20
-
-
-/*
-** generic extra include file
-*/
-#if defined(LUA_USER_H)
-#include LUA_USER_H
-#endif
-
-
-/* type of numbers in Lua */
-typedef LUA_NUMBER lua_Number;
-
-
-/* type for integer functions */
-typedef LUA_INTEGER lua_Integer;
-
-
-
-/*
-** state manipulation
-*/
-LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
-LUA_API void       (lua_close) (lua_State *L);
-LUA_API lua_State *(lua_newthread) (lua_State *L);
-
-LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
-
-
-/*
-** basic stack manipulation
-*/
-LUA_API int   (lua_gettop) (lua_State *L);
-LUA_API void  (lua_settop) (lua_State *L, int idx);
-LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
-LUA_API void  (lua_remove) (lua_State *L, int idx);
-LUA_API void  (lua_insert) (lua_State *L, int idx);
-LUA_API void  (lua_replace) (lua_State *L, int idx);
-LUA_API int   (lua_checkstack) (lua_State *L, int sz);
-
-LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
-
-
-/*
-** access functions (stack -> C)
-*/
-
-LUA_API int             (lua_isnumber) (lua_State *L, int idx);
-LUA_API int             (lua_isstring) (lua_State *L, int idx);
-LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
-LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
-LUA_API int             (lua_type) (lua_State *L, int idx);
-LUA_API const char     *(lua_typename) (lua_State *L, int tp);
-
-LUA_API int            (lua_equal) (lua_State *L, int idx1, int idx2);
-LUA_API int            (lua_rawequal) (lua_State *L, int idx1, int idx2);
-LUA_API int            (lua_lessthan) (lua_State *L, int idx1, int idx2);
-
-LUA_API lua_Number      (lua_tonumber) (lua_State *L, int idx);
-LUA_API lua_Integer     (lua_tointeger) (lua_State *L, int idx);
-LUA_API int             (lua_toboolean) (lua_State *L, int idx);
-LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
-LUA_API size_t          (lua_objlen) (lua_State *L, int idx);
-LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
-LUA_API void          *(lua_touserdata) (lua_State *L, int idx);
-LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
-LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
-
-
-/*
-** push functions (C -> stack)
-*/
-LUA_API void  (lua_pushnil) (lua_State *L);
-LUA_API void  (lua_pushnumber) (lua_State *L, lua_Number n);
-LUA_API void  (lua_pushinteger) (lua_State *L, lua_Integer n);
-LUA_API void  (lua_pushlstring) (lua_State *L, const char *s, size_t l);
-LUA_API void  (lua_pushstring) (lua_State *L, const char *s);
-LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
-                                                      va_list argp);
-LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
-LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
-LUA_API void  (lua_pushboolean) (lua_State *L, int b);
-LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
-LUA_API int   (lua_pushthread) (lua_State *L);
-
-
-/*
-** get functions (Lua -> stack)
-*/
-LUA_API void  (lua_gettable) (lua_State *L, int idx);
-LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_rawget) (lua_State *L, int idx);
-LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
-LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
-LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
-LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
-LUA_API void  (lua_getfenv) (lua_State *L, int idx);
-
-
-/*
-** set functions (stack -> Lua)
-*/
-LUA_API void  (lua_settable) (lua_State *L, int idx);
-LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_rawset) (lua_State *L, int idx);
-LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
-LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
-LUA_API int   (lua_setfenv) (lua_State *L, int idx);
-
-
-/*
-** `load' and `call' functions (load and run Lua code)
-*/
-LUA_API void  (lua_call) (lua_State *L, int nargs, int nresults);
-LUA_API int   (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
-LUA_API int   (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
-LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
-                                        const char *chunkname);
-
-LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
-
-
-/*
-** coroutine functions
-*/
-LUA_API int  (lua_yield) (lua_State *L, int nresults);
-LUA_API int  (lua_resume) (lua_State *L, int narg);
-LUA_API int  (lua_status) (lua_State *L);
-
-/*
-** garbage-collection function and options
-*/
-
-#define LUA_GCSTOP             0
-#define LUA_GCRESTART          1
-#define LUA_GCCOLLECT          2
-#define LUA_GCCOUNT            3
-#define LUA_GCCOUNTB           4
-#define LUA_GCSTEP             5
-#define LUA_GCSETPAUSE         6
-#define LUA_GCSETSTEPMUL       7
-
-LUA_API int (lua_gc) (lua_State *L, int what, int data);
-
-
-/*
-** miscellaneous functions
-*/
-
-LUA_API int   (lua_error) (lua_State *L);
-
-LUA_API int   (lua_next) (lua_State *L, int idx);
-
-LUA_API void  (lua_concat) (lua_State *L, int n);
-
-LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
-LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
-
-
-
-/*
-** ===============================================================
-** some useful macros
-** ===============================================================
-*/
-
-#define lua_pop(L,n)           lua_settop(L, -(n)-1)
-
-#define lua_newtable(L)                lua_createtable(L, 0, 0)
-
-#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
-
-#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
-
-#define lua_strlen(L,i)                lua_objlen(L, (i))
-
-#define lua_isfunction(L,n)    (lua_type(L, (n)) == LUA_TFUNCTION)
-#define lua_istable(L,n)       (lua_type(L, (n)) == LUA_TTABLE)
-#define lua_islightuserdata(L,n)       (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
-#define lua_isnil(L,n)         (lua_type(L, (n)) == LUA_TNIL)
-#define lua_isboolean(L,n)     (lua_type(L, (n)) == LUA_TBOOLEAN)
-#define lua_isthread(L,n)      (lua_type(L, (n)) == LUA_TTHREAD)
-#define lua_isnone(L,n)                (lua_type(L, (n)) == LUA_TNONE)
-#define lua_isnoneornil(L, n)  (lua_type(L, (n)) <= 0)
-
-#define lua_pushliteral(L, s)  \
-       lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
-
-#define lua_setglobal(L,s)     lua_setfield(L, LUA_GLOBALSINDEX, (s))
-#define lua_getglobal(L,s)     lua_getfield(L, LUA_GLOBALSINDEX, (s))
-
-#define lua_tostring(L,i)      lua_tolstring(L, (i), NULL)
-
-
-
-/*
-** compatibility macros and functions
-*/
-
-#define lua_open()     luaL_newstate()
-
-#define lua_getregistry(L)     lua_pushvalue(L, LUA_REGISTRYINDEX)
-
-#define lua_getgccount(L)      lua_gc(L, LUA_GCCOUNT, 0)
-
-#define lua_Chunkreader                lua_Reader
-#define lua_Chunkwriter                lua_Writer
-
-
-/* hack */
-LUA_API void lua_setlevel      (lua_State *from, lua_State *to);
-
-
-/*
-** {======================================================================
-** Debug API
-** =======================================================================
-*/
-
-
-/*
-** Event codes
-*/
-#define LUA_HOOKCALL   0
-#define LUA_HOOKRET    1
-#define LUA_HOOKLINE   2
-#define LUA_HOOKCOUNT  3
-#define LUA_HOOKTAILRET 4
-
-
-/*
-** Event masks
-*/
-#define LUA_MASKCALL   (1 << LUA_HOOKCALL)
-#define LUA_MASKRET    (1 << LUA_HOOKRET)
-#define LUA_MASKLINE   (1 << LUA_HOOKLINE)
-#define LUA_MASKCOUNT  (1 << LUA_HOOKCOUNT)
-
-typedef struct lua_Debug lua_Debug;  /* activation record */
-
-
-/* Functions to be called by the debuger in specific events */
-typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
-
-
-LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
-LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
-
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
-LUA_API lua_Hook lua_gethook (lua_State *L);
-LUA_API int lua_gethookmask (lua_State *L);
-LUA_API int lua_gethookcount (lua_State *L);
-
-
-struct lua_Debug {
-  int event;
-  const char *name;    /* (n) */
-  const char *namewhat;        /* (n) `global', `local', `field', `method' */
-  const char *what;    /* (S) `Lua', `C', `main', `tail' */
-  const char *source;  /* (S) */
-  int currentline;     /* (l) */
-  int nups;            /* (u) number of upvalues */
-  int linedefined;     /* (S) */
-  int lastlinedefined; /* (S) */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  int i_ci;  /* active function */
-};
-
-/* }====================================================================== */
-
-
-/******************************************************************************
-* Copyright (C) 1994-2008 Lua.org, PUC-Rio.  All rights reserved.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/luac.c b/source3/lua-5.1.4/src/luac.c
deleted file mode 100644 (file)
index d070173..0000000
--- a/source3/lua-5.1.4/src/luac.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
-** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $
-** Lua compiler (saves bytecodes to files; also list bytecodes)
-** See Copyright Notice in lua.h
-*/
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define luac_c
-#define LUA_CORE
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstring.h"
-#include "lundump.h"
-
-#define PROGNAME       "luac"          /* default program name */
-#define        OUTPUT          PROGNAME ".out" /* default output file */
-
-static int listing=0;                  /* list bytecodes? */
-static int dumping=1;                  /* dump bytecodes? */
-static int stripping=0;                        /* strip debug information? */
-static char Output[]={ OUTPUT };       /* default output file name */
-static const char* output=Output;      /* actual output file name */
-static const char* progname=PROGNAME;  /* actual program name */
-
-static void fatal(const char* message)
-{
- fprintf(stderr,"%s: %s\n",progname,message);
- exit(EXIT_FAILURE);
-}
-
-static void cannot(const char* what)
-{
- fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
- exit(EXIT_FAILURE);
-}
-
-static void usage(const char* message)
-{
- if (*message=='-')
-  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
- else
-  fprintf(stderr,"%s: %s\n",progname,message);
- fprintf(stderr,
- "usage: %s [options] [filenames].\n"
- "Available options are:\n"
- "  -        process stdin\n"
- "  -l       list\n"
- "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
- "  -p       parse only\n"
- "  -s       strip debug information\n"
- "  -v       show version information\n"
- "  --       stop handling options\n",
- progname,Output);
- exit(EXIT_FAILURE);
-}
-
-#define        IS(s)   (strcmp(argv[i],s)==0)
-
-static int doargs(int argc, char* argv[])
-{
- int i;
- int version=0;
- if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
- for (i=1; i<argc; i++)
- {
-  if (*argv[i]!='-')                   /* end of options; keep it */
-   break;
-  else if (IS("--"))                   /* end of options; skip it */
-  {
-   ++i;
-   if (version) ++version;
-   break;
-  }
-  else if (IS("-"))                    /* end of options; use stdin */
-   break;
-  else if (IS("-l"))                   /* list */
-   ++listing;
-  else if (IS("-o"))                   /* output file */
-  {
-   output=argv[++i];
-   if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
-   if (IS("-")) output=NULL;
-  }
-  else if (IS("-p"))                   /* parse only */
-   dumping=0;
-  else if (IS("-s"))                   /* strip debug information */
-   stripping=1;
-  else if (IS("-v"))                   /* show version */
-   ++version;
-  else                                 /* unknown option */
-   usage(argv[i]);
- }
- if (i==argc && (listing || !dumping))
- {
-  dumping=0;
-  argv[--i]=Output;
- }
- if (version)
- {
-  printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
-  if (version==argc-1) exit(EXIT_SUCCESS);
- }
- return i;
-}
-
-#define toproto(L,i) (clvalue(L->top+(i))->l.p)
-
-static const Proto* combine(lua_State* L, int n)
-{
- if (n==1)
-  return toproto(L,-1);
- else
- {
-  int i,pc;
-  Proto* f=luaF_newproto(L);
-  setptvalue2s(L,L->top,f); incr_top(L);
-  f->source=luaS_newliteral(L,"=(" PROGNAME ")");
-  f->maxstacksize=1;
-  pc=2*n+1;
-  f->code=luaM_newvector(L,pc,Instruction);
-  f->sizecode=pc;
-  f->p=luaM_newvector(L,n,Proto*);
-  f->sizep=n;
-  pc=0;
-  for (i=0; i<n; i++)
-  {
-   f->p[i]=toproto(L,i-n-1);
-   f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
-   f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
-  }
-  f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
-  return f;
- }
-}
-
-static int writer(lua_State* L, const void* p, size_t size, void* u)
-{
- UNUSED(L);
- return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
-}
-
-struct Smain {
- int argc;
- char** argv;
-};
-
-static int pmain(lua_State* L)
-{
- struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
- int argc=s->argc;
- char** argv=s->argv;
- const Proto* f;
- int i;
- if (!lua_checkstack(L,argc)) fatal("too many input files");
- for (i=0; i<argc; i++)
- {
-  const char* filename=IS("-") ? NULL : argv[i];
-  if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
- }
- f=combine(L,argc);
- if (listing) luaU_print(f,listing>1);
- if (dumping)
- {
-  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
-  if (D==NULL) cannot("open");
-  lua_lock(L);
-  luaU_dump(L,f,writer,D,stripping);
-  lua_unlock(L);
-  if (ferror(D)) cannot("write");
-  if (fclose(D)) cannot("close");
- }
- return 0;
-}
-
-int main(int argc, char* argv[])
-{
- lua_State* L;
- struct Smain s;
- int i=doargs(argc,argv);
- argc-=i; argv+=i;
- if (argc<=0) usage("no input files given");
- L=lua_open();
- if (L==NULL) fatal("not enough memory for state");
- s.argc=argc;
- s.argv=argv;
- if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
- lua_close(L);
- return EXIT_SUCCESS;
-}

diff --git a/source3/lua-5.1.4/src/luaconf.h b/source3/lua-5.1.4/src/luaconf.h
deleted file mode 100644 (file)
index 1d8e630..0000000
--- a/source3/lua-5.1.4/src/luaconf.h
+++ /dev/null
@@ -1,762 +0,0 @@
-/*
-** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $
-** Configuration file for Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lconfig_h
-#define lconfig_h
-
-#include <limits.h>
-#include <stddef.h>
-
-
-/*
-** ==================================================================
-** Search for "@@" to find all configurable definitions.
-** ===================================================================
-*/
-
-
-/*
-@@ LUA_ANSI controls the use of non-ansi features.
-** CHANGE it (define it) if you want Lua to avoid the use of any
-** non-ansi feature or library.
-*/
-#if defined(__STRICT_ANSI__)
-#define LUA_ANSI
-#endif
-
-
-#if !defined(LUA_ANSI) && defined(_WIN32)
-#define LUA_WIN
-#endif
-
-#if defined(LUA_USE_LINUX)
-#define LUA_USE_POSIX
-#define LUA_USE_DLOPEN         /* needs an extra library: -ldl */
-#define LUA_USE_READLINE       /* needs some extra libraries */
-#endif
-
-#if defined(LUA_USE_MACOSX)
-#define LUA_USE_POSIX
-#define LUA_DL_DYLD            /* does not need extra library */
-#endif
-
-
-
-/*
-@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
-@* Interfaces Extension (XSI).
-** CHANGE it (define it) if your system is XSI compatible.
-*/
-#if defined(LUA_USE_POSIX)
-#define LUA_USE_MKSTEMP
-#define LUA_USE_ISATTY
-#define LUA_USE_POPEN
-#define LUA_USE_ULONGJMP
-#endif
-
-
-/*
-@@ LUA_PATH and LUA_CPATH are the names of the environment variables that
-@* Lua check to set its paths.
-@@ LUA_INIT is the name of the environment variable that Lua
-@* checks for initialization code.
-** CHANGE them if you want different names.
-*/
-#define LUA_PATH        "LUA_PATH"
-#define LUA_CPATH       "LUA_CPATH"
-#define LUA_INIT       "LUA_INIT"
-
-
-/*
-@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
-@* Lua libraries.
-@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
-@* C libraries.
-** CHANGE them if your machine has a non-conventional directory
-** hierarchy or if you want to install your libraries in
-** non-conventional directories.
-*/
-#if defined(_WIN32)
-/*
-** In Windows, any exclamation mark ('!') in the path is replaced by the
-** path of the directory of the executable file of the current process.
-*/
-#define LUA_LDIR       "!\\lua\\"
-#define LUA_CDIR       "!\\"
-#define LUA_PATH_DEFAULT  \
-               ".\\?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
-                            LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua"
-#define LUA_CPATH_DEFAULT \
-       ".\\?.dll;"  LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll"
-
-#else
-#define LUA_ROOT       "/usr/local/"
-#define LUA_LDIR       LUA_ROOT "share/lua/5.1/"
-#define LUA_CDIR       LUA_ROOT "lib/lua/5.1/"
-#define LUA_PATH_DEFAULT  \
-               "./?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
-                           LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua"
-#define LUA_CPATH_DEFAULT \
-       "./?.so;"  LUA_CDIR"?.so;" LUA_CDIR"loadall.so"
-#endif
-
-
-/*
-@@ LUA_DIRSEP is the directory separator (for submodules).
-** CHANGE it if your machine does not use "/" as the directory separator
-** and is not Windows. (On Windows Lua automatically uses "\".)
-*/
-#if defined(_WIN32)
-#define LUA_DIRSEP     "\\"
-#else
-#define LUA_DIRSEP     "/"
-#endif
-
-
-/*
-@@ LUA_PATHSEP is the character that separates templates in a path.
-@@ LUA_PATH_MARK is the string that marks the substitution points in a
-@* template.
-@@ LUA_EXECDIR in a Windows path is replaced by the executable's
-@* directory.
-@@ LUA_IGMARK is a mark to ignore all before it when bulding the
-@* luaopen_ function name.
-** CHANGE them if for some reason your system cannot use those
-** characters. (E.g., if one of those characters is a common character
-** in file/directory names.) Probably you do not need to change them.
-*/
-#define LUA_PATHSEP    ";"
-#define LUA_PATH_MARK  "?"
-#define LUA_EXECDIR    "!"
-#define LUA_IGMARK     "-"
-
-
-/*
-@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
-** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
-** machines, ptrdiff_t gives a good choice between int or long.)
-*/
-#define LUA_INTEGER    ptrdiff_t
-
-
-/*
-@@ LUA_API is a mark for all core API functions.
-@@ LUALIB_API is a mark for all standard library functions.
-** CHANGE them if you need to define those functions in some special way.
-** For instance, if you want to create one Windows DLL with the core and
-** the libraries, you may want to use the following definition (define
-** LUA_BUILD_AS_DLL to get it).
-*/
-#if defined(LUA_BUILD_AS_DLL)
-
-#if defined(LUA_CORE) || defined(LUA_LIB)
-#define LUA_API __declspec(dllexport)
-#else
-#define LUA_API __declspec(dllimport)
-#endif
-
-#else
-
-#define LUA_API                extern
-
-#endif
-
-/* more often than not the libs go together with the core */
-#define LUALIB_API     LUA_API
-
-
-/*
-@@ LUAI_FUNC is a mark for all extern functions that are not to be
-@* exported to outside modules.
-@@ LUAI_DATA is a mark for all extern (const) variables that are not to
-@* be exported to outside modules.
-** CHANGE them if you need to mark them in some special way. Elf/gcc
-** (versions 3.2 and later) mark them as "hidden" to optimize access
-** when Lua is compiled as a shared library.
-*/
-#if defined(luaall_c)
-#define LUAI_FUNC      static
-#define LUAI_DATA      /* empty */
-
-#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
-      defined(__ELF__)
-#define LUAI_FUNC      __attribute__((visibility("hidden"))) extern
-#define LUAI_DATA      LUAI_FUNC
-
-#else
-#define LUAI_FUNC      extern
-#define LUAI_DATA      extern
-#endif
-
-
-
-/*
-@@ LUA_QL describes how error messages quote program elements.
-** CHANGE it if you want a different appearance.
-*/
-#define LUA_QL(x)      "'" x "'"
-#define LUA_QS         LUA_QL("%s")
-
-
-/*
-@@ LUA_IDSIZE gives the maximum size for the description of the source
-@* of a function in debug information.
-** CHANGE it if you want a different size.
-*/
-#define LUA_IDSIZE     60
-
-
-/*
-** {==================================================================
-** Stand-alone configuration
-** ===================================================================
-*/
-
-#if defined(lua_c) || defined(luaall_c)
-
-/*
-@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
-@* is, whether we're running lua interactively).
-** CHANGE it if you have a better definition for non-POSIX/non-Windows
-** systems.
-*/
-#if defined(LUA_USE_ISATTY)
-#include <unistd.h>
-#define lua_stdin_is_tty()     isatty(0)
-#elif defined(LUA_WIN)
-#include <io.h>
-#include <stdio.h>
-#define lua_stdin_is_tty()     _isatty(_fileno(stdin))
-#else
-#define lua_stdin_is_tty()     1  /* assume stdin is a tty */
-#endif
-
-
-/*
-@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
-@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
-** CHANGE them if you want different prompts. (You can also change the
-** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
-*/
-#define LUA_PROMPT             "> "
-#define LUA_PROMPT2            ">> "
-
-
-/*
-@@ LUA_PROGNAME is the default name for the stand-alone Lua program.
-** CHANGE it if your stand-alone interpreter has a different name and
-** your system is not able to detect that name automatically.
-*/
-#define LUA_PROGNAME           "lua"
-
-
-/*
-@@ LUA_MAXINPUT is the maximum length for an input line in the
-@* stand-alone interpreter.
-** CHANGE it if you need longer lines.
-*/
-#define LUA_MAXINPUT   512
-
-
-/*
-@@ lua_readline defines how to show a prompt and then read a line from
-@* the standard input.
-@@ lua_saveline defines how to "save" a read line in a "history".
-@@ lua_freeline defines how to free a line read by lua_readline.
-** CHANGE them if you want to improve this functionality (e.g., by using
-** GNU readline and history facilities).
-*/
-#if defined(LUA_USE_READLINE)
-#include <stdio.h>
-#include <readline/readline.h>
-#include <readline/history.h>
-#define lua_readline(L,b,p)    ((void)L, ((b)=readline(p)) != NULL)
-#define lua_saveline(L,idx) \
-       if (lua_strlen(L,idx) > 0)  /* non-empty line? */ \
-         add_history(lua_tostring(L, idx));  /* add it to history */
-#define lua_freeline(L,b)      ((void)L, free(b))
-#else
-#define lua_readline(L,b,p)    \
-       ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
-       fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
-#define lua_saveline(L,idx)    { (void)L; (void)idx; }
-#define lua_freeline(L,b)      { (void)L; (void)b; }
-#endif
-
-#endif
-
-/* }================================================================== */
-
-
-/*
-@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles
-@* as a percentage.
-** CHANGE it if you want the GC to run faster or slower (higher values
-** mean larger pauses which mean slower collection.) You can also change
-** this value dynamically.
-*/
-#define LUAI_GCPAUSE   200  /* 200% (wait memory to double before next GC) */
-
-
-/*
-@@ LUAI_GCMUL defines the default speed of garbage collection relative to
-@* memory allocation as a percentage.
-** CHANGE it if you want to change the granularity of the garbage
-** collection. (Higher values mean coarser collections. 0 represents
-** infinity, where each step performs a full collection.) You can also
-** change this value dynamically.
-*/
-#define LUAI_GCMUL     200 /* GC runs 'twice the speed' of memory allocation */
-
-
-
-/*
-@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.
-** CHANGE it (define it) if you want exact compatibility with the
-** behavior of setn/getn in Lua 5.0.
-*/
-#undef LUA_COMPAT_GETN
-
-/*
-@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
-** CHANGE it to undefined as soon as you do not need a global 'loadlib'
-** function (the function is still available as 'package.loadlib').
-*/
-#undef LUA_COMPAT_LOADLIB
-
-/*
-@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
-** CHANGE it to undefined as soon as your programs use only '...' to
-** access vararg parameters (instead of the old 'arg' table).
-*/
-#define LUA_COMPAT_VARARG
-
-/*
-@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
-** CHANGE it to undefined as soon as your programs use 'math.fmod' or
-** the new '%' operator instead of 'math.mod'.
-*/
-#define LUA_COMPAT_MOD
-
-/*
-@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
-@* facility.
-** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
-** off the advisory error when nesting [[...]].
-*/
-#define LUA_COMPAT_LSTR                1
-
-/*
-@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
-** CHANGE it to undefined as soon as you rename 'string.gfind' to
-** 'string.gmatch'.
-*/
-#define LUA_COMPAT_GFIND
-
-/*
-@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
-@* behavior.
-** CHANGE it to undefined as soon as you replace to 'luaL_register'
-** your uses of 'luaL_openlib'
-*/
-#define LUA_COMPAT_OPENLIB
-
-
-
-/*
-@@ luai_apicheck is the assert macro used by the Lua-C API.
-** CHANGE luai_apicheck if you want Lua to perform some checks in the
-** parameters it gets from API calls. This may slow down the interpreter
-** a bit, but may be quite useful when debugging C code that interfaces
-** with Lua. A useful redefinition is to use assert.h.
-*/
-#if defined(LUA_USE_APICHECK)
-#include <assert.h>
-#define luai_apicheck(L,o)     { (void)L; assert(o); }
-#else
-#define luai_apicheck(L,o)     { (void)L; }
-#endif
-
-
-/*
-@@ LUAI_BITSINT defines the number of bits in an int.
-** CHANGE here if Lua cannot automatically detect the number of bits of
-** your machine. Probably you do not need to change this.
-*/
-/* avoid overflows in comparison */
-#if INT_MAX-20 < 32760
-#define LUAI_BITSINT   16
-#elif INT_MAX > 2147483640L
-/* int has at least 32 bits */
-#define LUAI_BITSINT   32
-#else
-#error "you must define LUA_BITSINT with number of bits in an integer"
-#endif
-
-
-/*
-@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
-@@ LUAI_INT32 is an signed integer with at least 32 bits.
-@@ LUAI_UMEM is an unsigned integer big enough to count the total
-@* memory used by Lua.
-@@ LUAI_MEM is a signed integer big enough to count the total memory
-@* used by Lua.
-** CHANGE here if for some weird reason the default definitions are not
-** good enough for your machine. (The definitions in the 'else'
-** part always works, but may waste space on machines with 64-bit
-** longs.) Probably you do not need to change this.
-*/
-#if LUAI_BITSINT >= 32
-#define LUAI_UINT32    unsigned int
-#define LUAI_INT32     int
-#define LUAI_MAXINT32  INT_MAX
-#define LUAI_UMEM      size_t
-#define LUAI_MEM       ptrdiff_t
-#else
-/* 16-bit ints */
-#define LUAI_UINT32    unsigned long
-#define LUAI_INT32     long
-#define LUAI_MAXINT32  LONG_MAX
-#define LUAI_UMEM      unsigned long
-#define LUAI_MEM       long
-#endif
-
-
-/*
-@@ LUAI_MAXCALLS limits the number of nested calls.
-** CHANGE it if you need really deep recursive calls. This limit is
-** arbitrary; its only purpose is to stop infinite recursion before
-** exhausting memory.
-*/
-#define LUAI_MAXCALLS  20000
-
-
-/*
-@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
-@* can use.
-** CHANGE it if you need lots of (Lua) stack space for your C
-** functions. This limit is arbitrary; its only purpose is to stop C
-** functions to consume unlimited stack space. (must be smaller than
-** -LUA_REGISTRYINDEX)
-*/
-#define LUAI_MAXCSTACK 8000
-
-
-
-/*
-** {==================================================================
-** CHANGE (to smaller values) the following definitions if your system
-** has a small C stack. (Or you may want to change them to larger
-** values if your system has a large C stack and these limits are
-** too rigid for you.) Some of these constants control the size of
-** stack-allocated arrays used by the compiler or the interpreter, while
-** others limit the maximum number of recursive calls that the compiler
-** or the interpreter can perform. Values too large may cause a C stack
-** overflow for some forms of deep constructs.
-** ===================================================================
-*/
-
-
-/*
-@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
-@* syntactical nested non-terminals in a program.
-*/
-#define LUAI_MAXCCALLS         200
-
-
-/*
-@@ LUAI_MAXVARS is the maximum number of local variables per function
-@* (must be smaller than 250).
-*/
-#define LUAI_MAXVARS           200
-
-
-/*
-@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
-@* (must be smaller than 250).
-*/
-#define LUAI_MAXUPVALUES       60
-
-
-/*
-@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
-*/
-#define LUAL_BUFFERSIZE                BUFSIZ
-
-/* }================================================================== */
-
-
-
-
-/*
-** {==================================================================
-@@ LUA_NUMBER is the type of numbers in Lua.
-** CHANGE the following definitions only if you want to build Lua
-** with a number type different from double. You may also need to
-** change lua_number2int & lua_number2integer.
-** ===================================================================
-*/
-
-#define LUA_NUMBER_DOUBLE
-#define LUA_NUMBER     double
-
-/*
-@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
-@* over a number.
-*/
-#define LUAI_UACNUMBER double
-
-
-/*
-@@ LUA_NUMBER_SCAN is the format for reading numbers.
-@@ LUA_NUMBER_FMT is the format for writing numbers.
-@@ lua_number2str converts a number to a string.
-@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
-@@ lua_str2number converts a string to a number.
-*/
-#define LUA_NUMBER_SCAN                "%lf"
-#define LUA_NUMBER_FMT         "%.14g"
-#define lua_number2str(s,n)    sprintf((s), LUA_NUMBER_FMT, (n))
-#define LUAI_MAXNUMBER2STR     32 /* 16 digits, sign, point, and \0 */
-#define lua_str2number(s,p)    strtod((s), (p))
-
-
-/*
-@@ The luai_num* macros define the primitive operations over numbers.
-*/
-#if defined(LUA_CORE)
-#include <math.h>
-#define luai_numadd(a,b)       ((a)+(b))
-#define luai_numsub(a,b)       ((a)-(b))
-#define luai_nummul(a,b)       ((a)*(b))
-#define luai_numdiv(a,b)       ((a)/(b))
-#define luai_nummod(a,b)       ((a) - floor((a)/(b))*(b))
-#define luai_numpow(a,b)       (pow(a,b))
-#define luai_numunm(a)         (-(a))
-#define luai_numeq(a,b)                ((a)==(b))
-#define luai_numlt(a,b)                ((a)<(b))
-#define luai_numle(a,b)                ((a)<=(b))
-#define luai_numisnan(a)       (!luai_numeq((a), (a)))
-#endif
-
-
-/*
-@@ lua_number2int is a macro to convert lua_Number to int.
-@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
-** CHANGE them if you know a faster way to convert a lua_Number to
-** int (with any rounding method and without throwing errors) in your
-** system. In Pentium machines, a naive typecast from double to int
-** in C is extremely slow, so any alternative is worth trying.
-*/
-
-/* On a Pentium, resort to a trick */
-#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
-    (defined(__i386) || defined (_M_IX86) || defined(__i386__))
-
-/* On a Microsoft compiler, use assembler */
-#if defined(_MSC_VER)
-
-#define lua_number2int(i,d)   __asm fld d   __asm fistp i
-#define lua_number2integer(i,n)                lua_number2int(i, n)
-
-/* the next trick should work on any Pentium, but sometimes clashes
-   with a DirectX idiosyncrasy */
-#else
-
-union luai_Cast { double l_d; long l_l; };
-#define lua_number2int(i,d) \
-  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
-#define lua_number2integer(i,n)                lua_number2int(i, n)
-
-#endif
-
-
-/* this option always works, but may be slow */
-#else
-#define lua_number2int(i,d)    ((i)=(int)(d))
-#define lua_number2integer(i,d)        ((i)=(lua_Integer)(d))
-
-#endif
-
-/* }================================================================== */
-
-
-/*
-@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
-** CHANGE it if your system requires alignments larger than double. (For
-** instance, if your system supports long doubles and they must be
-** aligned in 16-byte boundaries, then you should add long double in the
-** union.) Probably you do not need to change this.
-*/
-#define LUAI_USER_ALIGNMENT_T  union { double u; void *s; long l; }
-
-
-/*
-@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
-** CHANGE them if you prefer to use longjmp/setjmp even with C++
-** or if want/don't to use _longjmp/_setjmp instead of regular
-** longjmp/setjmp. By default, Lua handles errors with exceptions when
-** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
-** and with longjmp/setjmp otherwise.
-*/
-#if defined(__cplusplus)
-/* C++ exceptions */
-#define LUAI_THROW(L,c)        throw(c)
-#define LUAI_TRY(L,c,a)        try { a } catch(...) \
-       { if ((c)->status == 0) (c)->status = -1; }
-#define luai_jmpbuf    int  /* dummy variable */
-
-#elif defined(LUA_USE_ULONGJMP)
-/* in Unix, try _longjmp/_setjmp (more efficient) */
-#define LUAI_THROW(L,c)        _longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)        if (_setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf    jmp_buf
-
-#else
-/* default handling with long jumps */
-#define LUAI_THROW(L,c)        longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)        if (setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf    jmp_buf
-
-#endif
-
-
-/*
-@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
-@* can do during pattern-matching.
-** CHANGE it if you need more captures. This limit is arbitrary.
-*/
-#define LUA_MAXCAPTURES                32
-
-
-/*
-@@ lua_tmpnam is the function that the OS library uses to create a
-@* temporary name.
-@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
-** CHANGE them if you have an alternative to tmpnam (which is considered
-** insecure) or if you want the original tmpnam anyway.  By default, Lua
-** uses tmpnam except when POSIX is available, where it uses mkstemp.
-*/
-#if defined(loslib_c) || defined(luaall_c)
-
-#if defined(LUA_USE_MKSTEMP)
-#include <unistd.h>
-#define LUA_TMPNAMBUFSIZE      32
-#define lua_tmpnam(b,e)        { \
-       strcpy(b, "/tmp/lua_XXXXXX"); \
-       e = mkstemp(b); \
-       if (e != -1) close(e); \
-       e = (e == -1); }
-
-#else
-#define LUA_TMPNAMBUFSIZE      L_tmpnam
-#define lua_tmpnam(b,e)                { e = (tmpnam(b) == NULL); }
-#endif
-
-#endif
-
-
-/*
-@@ lua_popen spawns a new process connected to the current one through
-@* the file streams.
-** CHANGE it if you have a way to implement it in your system.
-*/
-#if defined(LUA_USE_POPEN)
-
-#define lua_popen(L,c,m)       ((void)L, fflush(NULL), popen(c,m))
-#define lua_pclose(L,file)     ((void)L, (pclose(file) != -1))
-
-#elif defined(LUA_WIN)
-
-#define lua_popen(L,c,m)       ((void)L, _popen(c,m))
-#define lua_pclose(L,file)     ((void)L, (_pclose(file) != -1))
-
-#else
-
-#define lua_popen(L,c,m)       ((void)((void)c, m),  \
-               luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
-#define lua_pclose(L,file)             ((void)((void)L, file), 0)
-
-#endif
-
-/*
-@@ LUA_DL_* define which dynamic-library system Lua should use.
-** CHANGE here if Lua has problems choosing the appropriate
-** dynamic-library system for your platform (either Windows' DLL, Mac's
-** dyld, or Unix's dlopen). If your system is some kind of Unix, there
-** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
-** it.  To use dlopen you also need to adapt the src/Makefile (probably
-** adding -ldl to the linker options), so Lua does not select it
-** automatically.  (When you change the makefile to add -ldl, you must
-** also add -DLUA_USE_DLOPEN.)
-** If you do not want any kind of dynamic library, undefine all these
-** options.
-** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
-*/
-#if defined(LUA_USE_DLOPEN)
-#define LUA_DL_DLOPEN
-#endif
-
-#if defined(LUA_WIN)
-#define LUA_DL_DLL
-#endif
-
-
-/*
-@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
-@* (the data goes just *before* the lua_State pointer).
-** CHANGE (define) this if you really need that. This value must be
-** a multiple of the maximum alignment required for your machine.
-*/
-#define LUAI_EXTRASPACE                0
-
-
-/*
-@@ luai_userstate* allow user-specific actions on threads.
-** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
-** extra when a thread is created/deleted/resumed/yielded.
-*/
-#define luai_userstateopen(L)          ((void)L)
-#define luai_userstateclose(L)         ((void)L)
-#define luai_userstatethread(L,L1)     ((void)L)
-#define luai_userstatefree(L)          ((void)L)
-#define luai_userstateresume(L,n)      ((void)L)
-#define luai_userstateyield(L,n)       ((void)L)
-
-
-/*
-@@ LUA_INTFRMLEN is the length modifier for integer conversions
-@* in 'string.format'.
-@@ LUA_INTFRM_T is the integer type correspoding to the previous length
-@* modifier.
-** CHANGE them if your system supports long long or does not support long.
-*/
-
-#if defined(LUA_USELONGLONG)
-
-#define LUA_INTFRMLEN          "ll"
-#define LUA_INTFRM_T           long long
-
-#else
-
-#define LUA_INTFRMLEN          "l"
-#define LUA_INTFRM_T           long
-
-#endif
-
-
-
-/* =================================================================== */
-
-/*
-** Local configuration. You can use this space to add your redefinitions
-** without modifying the main part of the file.
-*/
-
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/lualib.h b/source3/lua-5.1.4/src/lualib.h
deleted file mode 100644 (file)
index e9ff9ba..0000000
--- a/source3/lua-5.1.4/src/lualib.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua standard libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lualib_h
-#define lualib_h
-
-#include "lua.h"
-
-
-/* Key to file-handle type */
-#define LUA_FILEHANDLE         "FILE*"
-
-
-#define LUA_COLIBNAME  "coroutine"
-LUALIB_API int (luaopen_base) (lua_State *L);
-
-#define LUA_TABLIBNAME "table"
-LUALIB_API int (luaopen_table) (lua_State *L);
-
-#define LUA_IOLIBNAME  "io"
-LUALIB_API int (luaopen_io) (lua_State *L);
-
-#define LUA_OSLIBNAME  "os"
-LUALIB_API int (luaopen_os) (lua_State *L);
-
-#define LUA_STRLIBNAME "string"
-LUALIB_API int (luaopen_string) (lua_State *L);
-
-#define LUA_MATHLIBNAME        "math"
-LUALIB_API int (luaopen_math) (lua_State *L);
-
-#define LUA_DBLIBNAME  "debug"
-LUALIB_API int (luaopen_debug) (lua_State *L);
-
-#define LUA_LOADLIBNAME        "package"
-LUALIB_API int (luaopen_package) (lua_State *L);
-
-
-/* open all previous libraries */
-LUALIB_API void (luaL_openlibs) (lua_State *L);
-
-
-
-#ifndef lua_assert
-#define lua_assert(x)  ((void)0)
-#endif
-
-
-#endif

diff --git a/source3/lua-5.1.4/src/lundump.c b/source3/lua-5.1.4/src/lundump.c
deleted file mode 100644 (file)
index 996b4eb..0000000
--- a/source3/lua-5.1.4/src/lundump.c
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
-** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#include <string.h>
-
-#define lundump_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstring.h"
-#include "lundump.h"
-#include "lzio.h"
-
-typedef struct {
- lua_State* L;
- ZIO* Z;
- Mbuffer* b;
- const char* name;
-} LoadState;
-
-#ifdef LUAC_TRUST_BINARIES
-#define IF(c,s)
-#define error(S,s)
-#else
-#define IF(c,s)                if (c) error(S,s)
-
-static void error(LoadState* S, const char* why)
-{
- luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
- luaD_throw(S->L,LUA_ERRSYNTAX);
-}
-#endif
-
-#define LoadMem(S,b,n,size)    LoadBlock(S,b,(n)*(size))
-#define        LoadByte(S)             (lu_byte)LoadChar(S)
-#define LoadVar(S,x)           LoadMem(S,&x,1,sizeof(x))
-#define LoadVector(S,b,n,size) LoadMem(S,b,n,size)
-
-static void LoadBlock(LoadState* S, void* b, size_t size)
-{
- size_t r=luaZ_read(S->Z,b,size);
- IF (r!=0, "unexpected end");
-}
-
-static int LoadChar(LoadState* S)
-{
- char x;
- LoadVar(S,x);
- return x;
-}
-
-static int LoadInt(LoadState* S)
-{
- int x;
- LoadVar(S,x);
- IF (x<0, "bad integer");
- return x;
-}
-
-static lua_Number LoadNumber(LoadState* S)
-{
- lua_Number x;
- LoadVar(S,x);
- return x;
-}
-
-static TString* LoadString(LoadState* S)
-{
- size_t size;
- LoadVar(S,size);
- if (size==0)
-  return NULL;
- else
- {
-  char* s=luaZ_openspace(S->L,S->b,size);
-  LoadBlock(S,s,size);
-  return luaS_newlstr(S->L,s,size-1);          /* remove trailing '\0' */
- }
-}
-
-static void LoadCode(LoadState* S, Proto* f)
-{
- int n=LoadInt(S);
- f->code=luaM_newvector(S->L,n,Instruction);
- f->sizecode=n;
- LoadVector(S,f->code,n,sizeof(Instruction));
-}
-
-static Proto* LoadFunction(LoadState* S, TString* p);
-
-static void LoadConstants(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- f->k=luaM_newvector(S->L,n,TValue);
- f->sizek=n;
- for (i=0; i<n; i++) setnilvalue(&f->k[i]);
- for (i=0; i<n; i++)
- {
-  TValue* o=&f->k[i];
-  int t=LoadChar(S);
-  switch (t)
-  {
-   case LUA_TNIL:
-       setnilvalue(o);
-       break;
-   case LUA_TBOOLEAN:
-       setbvalue(o,LoadChar(S)!=0);
-       break;
-   case LUA_TNUMBER:
-       setnvalue(o,LoadNumber(S));
-       break;
-   case LUA_TSTRING:
-       setsvalue2n(S->L,o,LoadString(S));
-       break;
-   default:
-       error(S,"bad constant");
-       break;
-  }
- }
- n=LoadInt(S);
- f->p=luaM_newvector(S->L,n,Proto*);
- f->sizep=n;
- for (i=0; i<n; i++) f->p[i]=NULL;
- for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
-}
-
-static void LoadDebug(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- f->lineinfo=luaM_newvector(S->L,n,int);
- f->sizelineinfo=n;
- LoadVector(S,f->lineinfo,n,sizeof(int));
- n=LoadInt(S);
- f->locvars=luaM_newvector(S->L,n,LocVar);
- f->sizelocvars=n;
- for (i=0; i<n; i++) f->locvars[i].varname=NULL;
- for (i=0; i<n; i++)
- {
-  f->locvars[i].varname=LoadString(S);
-  f->locvars[i].startpc=LoadInt(S);
-  f->locvars[i].endpc=LoadInt(S);
- }
- n=LoadInt(S);
- f->upvalues=luaM_newvector(S->L,n,TString*);
- f->sizeupvalues=n;
- for (i=0; i<n; i++) f->upvalues[i]=NULL;
- for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
-}
-
-static Proto* LoadFunction(LoadState* S, TString* p)
-{
- Proto* f;
- if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
- f=luaF_newproto(S->L);
- setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
- f->source=LoadString(S); if (f->source==NULL) f->source=p;
- f->linedefined=LoadInt(S);
- f->lastlinedefined=LoadInt(S);
- f->nups=LoadByte(S);
- f->numparams=LoadByte(S);
- f->is_vararg=LoadByte(S);
- f->maxstacksize=LoadByte(S);
- LoadCode(S,f);
- LoadConstants(S,f);
- LoadDebug(S,f);
- IF (!luaG_checkcode(f), "bad code");
- S->L->top--;
- S->L->nCcalls--;
- return f;
-}
-
-static void LoadHeader(LoadState* S)
-{
- char h[LUAC_HEADERSIZE];
- char s[LUAC_HEADERSIZE];
- luaU_header(h);
- LoadBlock(S,s,LUAC_HEADERSIZE);
- IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
-}
-
-/*
-** load precompiled chunk
-*/
-Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
-{
- LoadState S;
- if (*name=='@' || *name=='=')
-  S.name=name+1;
- else if (*name==LUA_SIGNATURE[0])
-  S.name="binary string";
- else
-  S.name=name;
- S.L=L;
- S.Z=Z;
- S.b=buff;
- LoadHeader(&S);
- return LoadFunction(&S,luaS_newliteral(L,"=?"));
-}
-
-/*
-* make header
-*/
-void luaU_header (char* h)
-{
- int x=1;
- memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
- h+=sizeof(LUA_SIGNATURE)-1;
- *h++=(char)LUAC_VERSION;
- *h++=(char)LUAC_FORMAT;
- *h++=(char)*(char*)&x;                                /* endianness */
- *h++=(char)sizeof(int);
- *h++=(char)sizeof(size_t);
- *h++=(char)sizeof(Instruction);
- *h++=(char)sizeof(lua_Number);
- *h++=(char)(((lua_Number)0.5)==0);            /* is lua_Number integral? */
-}

diff --git a/source3/lua-5.1.4/src/lundump.h b/source3/lua-5.1.4/src/lundump.h
deleted file mode 100644 (file)
index c80189d..0000000
--- a/source3/lua-5.1.4/src/lundump.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lundump_h
-#define lundump_h
-
-#include "lobject.h"
-#include "lzio.h"
-
-/* load one chunk; from lundump.c */
-LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
-
-/* make header; from lundump.c */
-LUAI_FUNC void luaU_header (char* h);
-
-/* dump one chunk; from ldump.c */
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
-
-#ifdef luac_c
-/* print one chunk; from print.c */
-LUAI_FUNC void luaU_print (const Proto* f, int full);
-#endif
-
-/* for header of binary files -- this is Lua 5.1 */
-#define LUAC_VERSION           0x51
-
-/* for header of binary files -- this is the official format */
-#define LUAC_FORMAT            0
-
-/* size of header of binary files */
-#define LUAC_HEADERSIZE                12
-
-#endif

diff --git a/source3/lua-5.1.4/src/lvm.c b/source3/lua-5.1.4/src/lvm.c
deleted file mode 100644 (file)
index 4399ec2..0000000
--- a/source3/lua-5.1.4/src/lvm.c
+++ /dev/null
@@ -1,762 +0,0 @@
-/*
-** $Id: lvm.c,v 2.63.1.3 2007/12/28 15:32:23 roberto Exp $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lvm_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-
-/* limit for table tag-method chains (to avoid loops) */
-#define MAXTAGLOOP     100
-
-
-const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
-  lua_Number num;
-  if (ttisnumber(obj)) return obj;
-  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
-    setnvalue(n, num);
-    return n;
-  }
-  else
-    return NULL;
-}
-
-
-int luaV_tostring (lua_State *L, StkId obj) {
-  if (!ttisnumber(obj))
-    return 0;
-  else {
-    char s[LUAI_MAXNUMBER2STR];
-    lua_Number n = nvalue(obj);
-    lua_number2str(s, n);
-    setsvalue2s(L, obj, luaS_new(L, s));
-    return 1;
-  }
-}
-
-
-static void traceexec (lua_State *L, const Instruction *pc) {
-  lu_byte mask = L->hookmask;
-  const Instruction *oldpc = L->savedpc;
-  L->savedpc = pc;
-  if ((mask & LUA_MASKCOUNT) && L->hookcount == 0) {
-    resethookcount(L);
-    luaD_callhook(L, LUA_HOOKCOUNT, -1);
-  }
-  if (mask & LUA_MASKLINE) {
-    Proto *p = ci_func(L->ci)->l.p;
-    int npc = pcRel(pc, p);
-    int newline = getline(p, npc);
-    /* call linehook when enter a new function, when jump back (loop),
-       or when enter a new line */
-    if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))
-      luaD_callhook(L, LUA_HOOKLINE, newline);
-  }
-}
-
-
-static void callTMres (lua_State *L, StkId res, const TValue *f,
-                        const TValue *p1, const TValue *p2) {
-  ptrdiff_t result = savestack(L, res);
-  setobj2s(L, L->top, f);  /* push function */
-  setobj2s(L, L->top+1, p1);  /* 1st argument */
-  setobj2s(L, L->top+2, p2);  /* 2nd argument */
-  luaD_checkstack(L, 3);
-  L->top += 3;
-  luaD_call(L, L->top - 3, 1);
-  res = restorestack(L, result);
-  L->top--;
-  setobjs2s(L, res, L->top);
-}
-
-
-
-static void callTM (lua_State *L, const TValue *f, const TValue *p1,
-                    const TValue *p2, const TValue *p3) {
-  setobj2s(L, L->top, f);  /* push function */
-  setobj2s(L, L->top+1, p1);  /* 1st argument */
-  setobj2s(L, L->top+2, p2);  /* 2nd argument */
-  setobj2s(L, L->top+3, p3);  /* 3th argument */
-  luaD_checkstack(L, 4);
-  L->top += 4;
-  luaD_call(L, L->top - 4, 0);
-}
-
-
-void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
-  int loop;
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;
-    if (ttistable(t)) {  /* `t' is a table? */
-      Table *h = hvalue(t);
-      const TValue *res = luaH_get(h, key); /* do a primitive get */
-      if (!ttisnil(res) ||  /* result is no nil? */
-          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
-        setobj2s(L, val, res);
-        return;
-      }
-      /* else will try the tag method */
-    }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
-      luaG_typeerror(L, t, "index");
-    if (ttisfunction(tm)) {
-      callTMres(L, val, tm, t, key);
-      return;
-    }
-    t = tm;  /* else repeat with `tm' */
-  }
-  luaG_runerror(L, "loop in gettable");
-}
-
-
-void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
-  int loop;
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;
-    if (ttistable(t)) {  /* `t' is a table? */
-      Table *h = hvalue(t);
-      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
-      if (!ttisnil(oldval) ||  /* result is no nil? */
-          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
-        setobj2t(L, oldval, val);
-        luaC_barriert(L, h, val);
-        return;
-      }
-      /* else will try the tag method */
-    }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
-      luaG_typeerror(L, t, "index");
-    if (ttisfunction(tm)) {
-      callTM(L, tm, t, key, val);
-      return;
-    }
-    t = tm;  /* else repeat with `tm' */
-  }
-  luaG_runerror(L, "loop in settable");
-}
-
-
-static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
-                       StkId res, TMS event) {
-  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
-  if (ttisnil(tm))
-    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
-  if (ttisnil(tm)) return 0;
-  callTMres(L, res, tm, p1, p2);
-  return 1;
-}
-
-
-static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
-                                  TMS event) {
-  const TValue *tm1 = fasttm(L, mt1, event);
-  const TValue *tm2;
-  if (tm1 == NULL) return NULL;  /* no metamethod */
-  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
-  tm2 = fasttm(L, mt2, event);
-  if (tm2 == NULL) return NULL;  /* no metamethod */
-  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */
-    return tm1;
-  return NULL;
-}
-
-
-static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
-                         TMS event) {
-  const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
-  const TValue *tm2;
-  if (ttisnil(tm1)) return -1;  /* no metamethod? */
-  tm2 = luaT_gettmbyobj(L, p2, event);
-  if (!luaO_rawequalObj(tm1, tm2))  /* different metamethods? */
-    return -1;
-  callTMres(L, L->top, tm1, p1, p2);
-  return !l_isfalse(L->top);
-}
-
-
-static int l_strcmp (const TString *ls, const TString *rs) {
-  const char *l = getstr(ls);
-  size_t ll = ls->tsv.len;
-  const char *r = getstr(rs);
-  size_t lr = rs->tsv.len;
-  for (;;) {
-    int temp = strcoll(l, r);
-    if (temp != 0) return temp;
-    else {  /* strings are equal up to a `\0' */
-      size_t len = strlen(l);  /* index of first `\0' in both strings */
-      if (len == lr)  /* r is finished? */
-        return (len == ll) ? 0 : 1;
-      else if (len == ll)  /* l is finished? */
-        return -1;  /* l is smaller than r (because r is not finished) */
-      /* both strings longer than `len'; go on comparing (after the `\0') */
-      len++;
-      l += len; ll -= len; r += len; lr -= len;
-    }
-  }
-}
-
-
-int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
-  int res;
-  if (ttype(l) != ttype(r))
-    return luaG_ordererror(L, l, r);
-  else if (ttisnumber(l))
-    return luai_numlt(nvalue(l), nvalue(r));
-  else if (ttisstring(l))
-    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
-  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
-    return res;
-  return luaG_ordererror(L, l, r);
-}
-
-
-static int lessequal (lua_State *L, const TValue *l, const TValue *r) {
-  int res;
-  if (ttype(l) != ttype(r))
-    return luaG_ordererror(L, l, r);
-  else if (ttisnumber(l))
-    return luai_numle(nvalue(l), nvalue(r));
-  else if (ttisstring(l))
-    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
-  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */
-    return res;
-  else if ((res = call_orderTM(L, r, l, TM_LT)) != -1)  /* else try `lt' */
-    return !res;
-  return luaG_ordererror(L, l, r);
-}
-
-
-int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
-  const TValue *tm;
-  lua_assert(ttype(t1) == ttype(t2));
-  switch (ttype(t1)) {
-    case LUA_TNIL: return 1;
-    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
-    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
-    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
-    case LUA_TUSERDATA: {
-      if (uvalue(t1) == uvalue(t2)) return 1;
-      tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,
-                         TM_EQ);
-      break;  /* will try TM */
-    }
-    case LUA_TTABLE: {
-      if (hvalue(t1) == hvalue(t2)) return 1;
-      tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
-      break;  /* will try TM */
-    }
-    default: return gcvalue(t1) == gcvalue(t2);
-  }
-  if (tm == NULL) return 0;  /* no TM? */
-  callTMres(L, L->top, tm, t1, t2);  /* call TM */
-  return !l_isfalse(L->top);
-}
-
-
-void luaV_concat (lua_State *L, int total, int last) {
-  do {
-    StkId top = L->base + last + 1;
-    int n = 2;  /* number of elements handled in this pass (at least 2) */
-    if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) {
-      if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
-        luaG_concaterror(L, top-2, top-1);
-    } else if (tsvalue(top-1)->len == 0)  /* second op is empty? */
-      (void)tostring(L, top - 2);  /* result is first op (as string) */
-    else {
-      /* at least two string values; get as many as possible */
-      size_t tl = tsvalue(top-1)->len;
-      char *buffer;
-      int i;
-      /* collect total length */
-      for (n = 1; n < total && tostring(L, top-n-1); n++) {
-        size_t l = tsvalue(top-n-1)->len;
-        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
-        tl += l;
-      }
-      buffer = luaZ_openspace(L, &G(L)->buff, tl);
-      tl = 0;
-      for (i=n; i>0; i--) {  /* concat all strings */
-        size_t l = tsvalue(top-i)->len;
-        memcpy(buffer+tl, svalue(top-i), l);
-        tl += l;
-      }
-      setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
-    }
-    total -= n-1;  /* got `n' strings to create 1 new */
-    last -= n-1;
-  } while (total > 1);  /* repeat until only 1 result left */
-}
-
-
-static void Arith (lua_State *L, StkId ra, const TValue *rb,
-                   const TValue *rc, TMS op) {
-  TValue tempb, tempc;
-  const TValue *b, *c;
-  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
-      (c = luaV_tonumber(rc, &tempc)) != NULL) {
-    lua_Number nb = nvalue(b), nc = nvalue(c);
-    switch (op) {
-      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
-      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
-      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
-      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
-      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
-      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
-      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
-      default: lua_assert(0); break;
-    }
-  }
-  else if (!call_binTM(L, rb, rc, ra, op))
-    luaG_aritherror(L, rb, rc);
-}
-
-
-
-/*
-** some macros for common tasks in `luaV_execute'
-*/
-
-#define runtime_check(L, c)    { if (!(c)) break; }
-
-#define RA(i)  (base+GETARG_A(i))
-/* to be used after possible stack reallocation */
-#define RB(i)  check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
-#define RC(i)  check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
-#define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
-       ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
-#define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
-       ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
-#define KBx(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
-
-
-#define dojump(L,pc,i) {(pc) += (i); luai_threadyield(L);}
-
-
-#define Protect(x)     { L->savedpc = pc; {x;}; base = L->base; }
-
-
-#define arith_op(op,tm) { \
-        TValue *rb = RKB(i); \
-        TValue *rc = RKC(i); \
-        if (ttisnumber(rb) && ttisnumber(rc)) { \
-          lua_Number nb = nvalue(rb), nc = nvalue(rc); \
-          setnvalue(ra, op(nb, nc)); \
-        } \
-        else \
-          Protect(Arith(L, ra, rb, rc, tm)); \
-      }
-
-
-
-void luaV_execute (lua_State *L, int nexeccalls) {
-  LClosure *cl;
-  StkId base;
-  TValue *k;
-  const Instruction *pc;
- reentry:  /* entry point */
-  lua_assert(isLua(L->ci));
-  pc = L->savedpc;
-  cl = &clvalue(L->ci->func)->l;
-  base = L->base;
-  k = cl->p->k;
-  /* main loop of interpreter */
-  for (;;) {
-    const Instruction i = *pc++;
-    StkId ra;
-    if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
-        (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
-      traceexec(L, pc);
-      if (L->status == LUA_YIELD) {  /* did hook yield? */
-        L->savedpc = pc - 1;
-        return;
-      }
-      base = L->base;
-    }
-    /* warning!! several calls may realloc the stack and invalidate `ra' */
-    ra = RA(i);
-    lua_assert(base == L->base && L->base == L->ci->base);
-    lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
-    lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
-    switch (GET_OPCODE(i)) {
-      case OP_MOVE: {
-        setobjs2s(L, ra, RB(i));
-        continue;
-      }
-      case OP_LOADK: {
-        setobj2s(L, ra, KBx(i));
-        continue;
-      }
-      case OP_LOADBOOL: {
-        setbvalue(ra, GETARG_B(i));
-        if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
-        continue;
-      }
-      case OP_LOADNIL: {
-        TValue *rb = RB(i);
-        do {
-          setnilvalue(rb--);
-        } while (rb >= ra);
-        continue;
-      }
-      case OP_GETUPVAL: {
-        int b = GETARG_B(i);
-        setobj2s(L, ra, cl->upvals[b]->v);
-        continue;
-      }
-      case OP_GETGLOBAL: {
-        TValue g;
-        TValue *rb = KBx(i);
-        sethvalue(L, &g, cl->env);
-        lua_assert(ttisstring(rb));
-        Protect(luaV_gettable(L, &g, rb, ra));
-        continue;
-      }
-      case OP_GETTABLE: {
-        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
-        continue;
-      }
-      case OP_SETGLOBAL: {
-        TValue g;
-        sethvalue(L, &g, cl->env);
-        lua_assert(ttisstring(KBx(i)));
-        Protect(luaV_settable(L, &g, KBx(i), ra));
-        continue;
-      }
-      case OP_SETUPVAL: {
-        UpVal *uv = cl->upvals[GETARG_B(i)];
-        setobj(L, uv->v, ra);
-        luaC_barrier(L, uv, ra);
-        continue;
-      }
-      case OP_SETTABLE: {
-        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
-        continue;
-      }
-      case OP_NEWTABLE: {
-        int b = GETARG_B(i);
-        int c = GETARG_C(i);
-        sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
-        Protect(luaC_checkGC(L));
-        continue;
-      }
-      case OP_SELF: {
-        StkId rb = RB(i);
-        setobjs2s(L, ra+1, rb);
-        Protect(luaV_gettable(L, rb, RKC(i), ra));
-        continue;
-      }
-      case OP_ADD: {
-        arith_op(luai_numadd, TM_ADD);
-        continue;
-      }
-      case OP_SUB: {
-        arith_op(luai_numsub, TM_SUB);
-        continue;
-      }
-      case OP_MUL: {
-        arith_op(luai_nummul, TM_MUL);
-        continue;
-      }
-      case OP_DIV: {
-        arith_op(luai_numdiv, TM_DIV);
-        continue;
-      }
-      case OP_MOD: {
-        arith_op(luai_nummod, TM_MOD);
-        continue;
-      }
-      case OP_POW: {
-        arith_op(luai_numpow, TM_POW);
-        continue;
-      }
-      case OP_UNM: {
-        TValue *rb = RB(i);
-        if (ttisnumber(rb)) {
-          lua_Number nb = nvalue(rb);
-          setnvalue(ra, luai_numunm(nb));
-        }
-        else {
-          Protect(Arith(L, ra, rb, rb, TM_UNM));
-        }
-        continue;
-      }
-      case OP_NOT: {
-        int res = l_isfalse(RB(i));  /* next assignment may change this value */
-        setbvalue(ra, res);
-        continue;
-      }
-      case OP_LEN: {
-        const TValue *rb = RB(i);
-        switch (ttype(rb)) {
-          case LUA_TTABLE: {
-            setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
-            break;
-          }
-          case LUA_TSTRING: {
-            setnvalue(ra, cast_num(tsvalue(rb)->len));
-            break;
-          }
-          default: {  /* try metamethod */
-            Protect(
-              if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
-                luaG_typeerror(L, rb, "get length of");
-            )
-          }
-        }
-        continue;
-      }
-      case OP_CONCAT: {
-        int b = GETARG_B(i);
-        int c = GETARG_C(i);
-        Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
-        setobjs2s(L, RA(i), base+b);
-        continue;
-      }
-      case OP_JMP: {
-        dojump(L, pc, GETARG_sBx(i));
-        continue;
-      }
-      case OP_EQ: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        Protect(
-          if (equalobj(L, rb, rc) == GETARG_A(i))
-            dojump(L, pc, GETARG_sBx(*pc));
-        )
-        pc++;
-        continue;
-      }
-      case OP_LT: {
-        Protect(
-          if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
-            dojump(L, pc, GETARG_sBx(*pc));
-        )
-        pc++;
-        continue;
-      }
-      case OP_LE: {
-        Protect(
-          if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
-            dojump(L, pc, GETARG_sBx(*pc));
-        )
-        pc++;
-        continue;
-      }
-      case OP_TEST: {
-        if (l_isfalse(ra) != GETARG_C(i))
-          dojump(L, pc, GETARG_sBx(*pc));
-        pc++;
-        continue;
-      }
-      case OP_TESTSET: {
-        TValue *rb = RB(i);
-        if (l_isfalse(rb) != GETARG_C(i)) {
-          setobjs2s(L, ra, rb);
-          dojump(L, pc, GETARG_sBx(*pc));
-        }
-        pc++;
-        continue;
-      }
-      case OP_CALL: {
-        int b = GETARG_B(i);
-        int nresults = GETARG_C(i) - 1;
-        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-        L->savedpc = pc;
-        switch (luaD_precall(L, ra, nresults)) {
-          case PCRLUA: {
-            nexeccalls++;
-            goto reentry;  /* restart luaV_execute over new Lua function */
-          }
-          case PCRC: {
-            /* it was a C function (`precall' called it); adjust results */
-            if (nresults >= 0) L->top = L->ci->top;
-            base = L->base;
-            continue;
-          }
-          default: {
-            return;  /* yield */
-          }
-        }
-      }
-      case OP_TAILCALL: {
-        int b = GETARG_B(i);
-        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-        L->savedpc = pc;
-        lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
-        switch (luaD_precall(L, ra, LUA_MULTRET)) {
-          case PCRLUA: {
-            /* tail call: put new frame in place of previous one */
-            CallInfo *ci = L->ci - 1;  /* previous frame */
-            int aux;
-            StkId func = ci->func;
-            StkId pfunc = (ci+1)->func;  /* previous function index */
-            if (L->openupval) luaF_close(L, ci->base);
-            L->base = ci->base = ci->func + ((ci+1)->base - pfunc);
-            for (aux = 0; pfunc+aux < L->top; aux++)  /* move frame down */
-              setobjs2s(L, func+aux, pfunc+aux);
-            ci->top = L->top = func+aux;  /* correct top */
-            lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
-            ci->savedpc = L->savedpc;
-            ci->tailcalls++;  /* one more call lost */
-            L->ci--;  /* remove new frame */
-            goto reentry;
-          }
-          case PCRC: {  /* it was a C function (`precall' called it) */
-            base = L->base;
-            continue;
-          }
-          default: {
-            return;  /* yield */
-          }
-        }
-      }
-      case OP_RETURN: {
-        int b = GETARG_B(i);
-        if (b != 0) L->top = ra+b-1;
-        if (L->openupval) luaF_close(L, base);
-        L->savedpc = pc;
-        b = luaD_poscall(L, ra);
-        if (--nexeccalls == 0)  /* was previous function running `here'? */
-          return;  /* no: return */
-        else {  /* yes: continue its execution */
-          if (b) L->top = L->ci->top;
-          lua_assert(isLua(L->ci));
-          lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);
-          goto reentry;
-        }
-      }
-      case OP_FORLOOP: {
-        lua_Number step = nvalue(ra+2);
-        lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
-        lua_Number limit = nvalue(ra+1);
-        if (luai_numlt(0, step) ? luai_numle(idx, limit)
-                                : luai_numle(limit, idx)) {
-          dojump(L, pc, GETARG_sBx(i));  /* jump back */
-          setnvalue(ra, idx);  /* update internal index... */
-          setnvalue(ra+3, idx);  /* ...and external index */
-        }
-        continue;
-      }
-      case OP_FORPREP: {
-        const TValue *init = ra;
-        const TValue *plimit = ra+1;
-        const TValue *pstep = ra+2;
-        L->savedpc = pc;  /* next steps may throw errors */
-        if (!tonumber(init, ra))
-          luaG_runerror(L, LUA_QL("for") " initial value must be a number");
-        else if (!tonumber(plimit, ra+1))
-          luaG_runerror(L, LUA_QL("for") " limit must be a number");
-        else if (!tonumber(pstep, ra+2))
-          luaG_runerror(L, LUA_QL("for") " step must be a number");
-        setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
-        dojump(L, pc, GETARG_sBx(i));
-        continue;
-      }
-      case OP_TFORLOOP: {
-        StkId cb = ra + 3;  /* call base */
-        setobjs2s(L, cb+2, ra+2);
-        setobjs2s(L, cb+1, ra+1);
-        setobjs2s(L, cb, ra);
-        L->top = cb+3;  /* func. + 2 args (state and index) */
-        Protect(luaD_call(L, cb, GETARG_C(i)));
-        L->top = L->ci->top;
-        cb = RA(i) + 3;  /* previous call may change the stack */
-        if (!ttisnil(cb)) {  /* continue loop? */
-          setobjs2s(L, cb-1, cb);  /* save control variable */
-          dojump(L, pc, GETARG_sBx(*pc));  /* jump back */
-        }
-        pc++;
-        continue;
-      }
-      case OP_SETLIST: {
-        int n = GETARG_B(i);
-        int c = GETARG_C(i);
-        int last;
-        Table *h;
-        if (n == 0) {
-          n = cast_int(L->top - ra) - 1;
-          L->top = L->ci->top;
-        }
-        if (c == 0) c = cast_int(*pc++);
-        runtime_check(L, ttistable(ra));
-        h = hvalue(ra);
-        last = ((c-1)*LFIELDS_PER_FLUSH) + n;
-        if (last > h->sizearray)  /* needs more space? */
-          luaH_resizearray(L, h, last);  /* pre-alloc it at once */
-        for (; n > 0; n--) {
-          TValue *val = ra+n;
-          setobj2t(L, luaH_setnum(L, h, last--), val);
-          luaC_barriert(L, h, val);
-        }
-        continue;
-      }
-      case OP_CLOSE: {
-        luaF_close(L, ra);
-        continue;
-      }
-      case OP_CLOSURE: {
-        Proto *p;
-        Closure *ncl;
-        int nup, j;
-        p = cl->p->p[GETARG_Bx(i)];
-        nup = p->nups;
-        ncl = luaF_newLclosure(L, nup, cl->env);
-        ncl->l.p = p;
-        for (j=0; j<nup; j++, pc++) {
-          if (GET_OPCODE(*pc) == OP_GETUPVAL)
-            ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
-          else {
-            lua_assert(GET_OPCODE(*pc) == OP_MOVE);
-            ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
-          }
-        }
-        setclvalue(L, ra, ncl);
-        Protect(luaC_checkGC(L));
-        continue;
-      }
-      case OP_VARARG: {
-        int b = GETARG_B(i) - 1;
-        int j;
-        CallInfo *ci = L->ci;
-        int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
-        if (b == LUA_MULTRET) {
-          Protect(luaD_checkstack(L, n));
-          ra = RA(i);  /* previous call may change the stack */
-          b = n;
-          L->top = ra + n;
-        }
-        for (j = 0; j < b; j++) {
-          if (j < n) {
-            setobjs2s(L, ra + j, ci->base - n + j);
-          }
-          else {
-            setnilvalue(ra + j);
-          }
-        }
-        continue;
-      }
-    }
-  }
-}

diff --git a/source3/lua-5.1.4/src/lvm.h b/source3/lua-5.1.4/src/lvm.h
deleted file mode 100644 (file)
index bfe4f56..0000000
--- a/source3/lua-5.1.4/src/lvm.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-** $Id: lvm.h,v 2.5.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lvm_h
-#define lvm_h
-
-
-#include "ldo.h"
-#include "lobject.h"
-#include "ltm.h"
-
-
-#define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o)))
-
-#define tonumber(o,n)  (ttype(o) == LUA_TNUMBER || \
-                         (((o) = luaV_tonumber(o,n)) != NULL))
-
-#define equalobj(L,o1,o2) \
-       (ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
-
-
-LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
-LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
-LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
-LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
-LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
-                                            StkId val);
-LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
-                                            StkId val);
-LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
-LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
-
-#endif

diff --git a/source3/lua-5.1.4/src/lzio.c b/source3/lua-5.1.4/src/lzio.c
deleted file mode 100644 (file)
index 4c6f890..0000000
--- a/source3/lua-5.1.4/src/lzio.c
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-** $Id: lzio.c,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
-** a generic input stream interface
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define lzio_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "llimits.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lzio.h"
-
-
-int luaZ_fill (ZIO *z) {
-  size_t size;
-  lua_State *L = z->L;
-  const char *buff;
-  lua_unlock(L);
-  buff = z->reader(L, z->data, &size);
-  lua_lock(L);
-  if (buff == NULL || size == 0) return EOZ;
-  z->n = size - 1;
-  z->p = buff;
-  return char2int(*(z->p++));
-}
-
-
-int luaZ_lookahead (ZIO *z) {
-  if (z->n == 0) {
-    if (luaZ_fill(z) == EOZ)
-      return EOZ;
-    else {
-      z->n++;  /* luaZ_fill removed first byte; put back it */
-      z->p--;
-    }
-  }
-  return char2int(*z->p);
-}
-
-
-void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
-  z->L = L;
-  z->reader = reader;
-  z->data = data;
-  z->n = 0;
-  z->p = NULL;
-}
-
-
-/* --------------------------------------------------------------- read --- */
-size_t luaZ_read (ZIO *z, void *b, size_t n) {
-  while (n) {
-    size_t m;
-    if (luaZ_lookahead(z) == EOZ)
-      return n;  /* return number of missing bytes */
-    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
-    memcpy(b, z->p, m);
-    z->n -= m;
-    z->p += m;
-    b = (char *)b + m;
-    n -= m;
-  }
-  return 0;
-}
-
-/* ------------------------------------------------------------------------ */
-char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
-  if (n > buff->buffsize) {
-    if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
-    luaZ_resizebuffer(L, buff, n);
-  }
-  return buff->buffer;
-}

diff --git a/source3/lua-5.1.4/src/lzio.h b/source3/lua-5.1.4/src/lzio.h
deleted file mode 100644 (file)
index 51d695d..0000000
--- a/source3/lua-5.1.4/src/lzio.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-** $Id: lzio.h,v 1.21.1.1 2007/12/27 13:02:25 roberto Exp $
-** Buffered streams
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lzio_h
-#define lzio_h
-
-#include "lua.h"
-
-#include "lmem.h"
-
-
-#define EOZ    (-1)                    /* end of stream */
-
-typedef struct Zio ZIO;
-
-#define char2int(c)    cast(int, cast(unsigned char, (c)))
-
-#define zgetc(z)  (((z)->n--)>0 ?  char2int(*(z)->p++) : luaZ_fill(z))
-
-typedef struct Mbuffer {
-  char *buffer;
-  size_t n;
-  size_t buffsize;
-} Mbuffer;
-
-#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
-
-#define luaZ_buffer(buff)      ((buff)->buffer)
-#define luaZ_sizebuffer(buff)  ((buff)->buffsize)
-#define luaZ_bufflen(buff)     ((buff)->n)
-
-#define luaZ_resetbuffer(buff) ((buff)->n = 0)
-
-
-#define luaZ_resizebuffer(L, buff, size) \
-       (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
-       (buff)->buffsize = size)
-
-#define luaZ_freebuffer(L, buff)       luaZ_resizebuffer(L, buff, 0)
-
-
-LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
-LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
-                                        void *data);
-LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);        /* read next n bytes */
-LUAI_FUNC int luaZ_lookahead (ZIO *z);
-
-
-
-/* --------- Private Part ------------------ */
-
-struct Zio {
-  size_t n;                    /* bytes still unread */
-  const char *p;               /* current position in buffer */
-  lua_Reader reader;
-  void* data;                  /* additional data */
-  lua_State *L;                        /* Lua state (for reader) */
-};
-
-
-LUAI_FUNC int luaZ_fill (ZIO *z);
-
-#endif

diff --git a/source3/lua-5.1.4/src/print.c b/source3/lua-5.1.4/src/print.c
deleted file mode 100644 (file)
index 508bbf3..0000000
--- a/source3/lua-5.1.4/src/print.c
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
-** $Id: print.c,v 1.55a 2006/05/31 13:30:05 lhf Exp $
-** print bytecodes
-** See Copyright Notice in lua.h
-*/
-
-#include <ctype.h>
-#include <stdio.h>
-
-#define luac_c
-#define LUA_CORE
-
-#include "ldebug.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lundump.h"
-
-#define PrintFunction  luaU_print
-
-#define Sizeof(x)      ((int)sizeof(x))
-#define VOID(p)                ((const void*)(p))
-
-static void PrintString(const TString* ts)
-{
- const char* s=getstr(ts);
- size_t i,n=ts->tsv.len;
- putchar('"');
- for (i=0; i<n; i++)
- {
-  int c=s[i];
-  switch (c)
-  {
-   case '"': printf("\\\""); break;
-   case '\\': printf("\\\\"); break;
-   case '\a': printf("\\a"); break;
-   case '\b': printf("\\b"); break;
-   case '\f': printf("\\f"); break;
-   case '\n': printf("\\n"); break;
-   case '\r': printf("\\r"); break;
-   case '\t': printf("\\t"); break;
-   case '\v': printf("\\v"); break;
-   default:    if (isprint((unsigned char)c))
-                       putchar(c);
-               else
-                       printf("\\%03u",(unsigned char)c);
-  }
- }
- putchar('"');
-}
-
-static void PrintConstant(const Proto* f, int i)
-{
- const TValue* o=&f->k[i];
- switch (ttype(o))
- {
-  case LUA_TNIL:
-       printf("nil");
-       break;
-  case LUA_TBOOLEAN:
-       printf(bvalue(o) ? "true" : "false");
-       break;
-  case LUA_TNUMBER:
-       printf(LUA_NUMBER_FMT,nvalue(o));
-       break;
-  case LUA_TSTRING:
-       PrintString(rawtsvalue(o));
-       break;
-  default:                             /* cannot happen */
-       printf("? type=%d",ttype(o));
-       break;
- }
-}
-
-static void PrintCode(const Proto* f)
-{
- const Instruction* code=f->code;
- int pc,n=f->sizecode;
- for (pc=0; pc<n; pc++)
- {
-  Instruction i=code[pc];
-  OpCode o=GET_OPCODE(i);
-  int a=GETARG_A(i);
-  int b=GETARG_B(i);
-  int c=GETARG_C(i);
-  int bx=GETARG_Bx(i);
-  int sbx=GETARG_sBx(i);
-  int line=getline(f,pc);
-  printf("\t%d\t",pc+1);
-  if (line>0) printf("[%d]\t",line); else printf("[-]\t");
-  printf("%-9s\t",luaP_opnames[o]);
-  switch (getOpMode(o))
-  {
-   case iABC:
-    printf("%d",a);
-    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b);
-    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c);
-    break;
-   case iABx:
-    if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx);
-    break;
-   case iAsBx:
-    if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx);
-    break;
-  }
-  switch (o)
-  {
-   case OP_LOADK:
-    printf("\t; "); PrintConstant(f,bx);
-    break;
-   case OP_GETUPVAL:
-   case OP_SETUPVAL:
-    printf("\t; %s", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : "-");
-    break;
-   case OP_GETGLOBAL:
-   case OP_SETGLOBAL:
-    printf("\t; %s",svalue(&f->k[bx]));
-    break;
-   case OP_GETTABLE:
-   case OP_SELF:
-    if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
-    break;
-   case OP_SETTABLE:
-   case OP_ADD:
-   case OP_SUB:
-   case OP_MUL:
-   case OP_DIV:
-   case OP_POW:
-   case OP_EQ:
-   case OP_LT:
-   case OP_LE:
-    if (ISK(b) || ISK(c))
-    {
-     printf("\t; ");
-     if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
-     printf(" ");
-     if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
-    }
-    break;
-   case OP_JMP:
-   case OP_FORLOOP:
-   case OP_FORPREP:
-    printf("\t; to %d",sbx+pc+2);
-    break;
-   case OP_CLOSURE:
-    printf("\t; %p",VOID(f->p[bx]));
-    break;
-   case OP_SETLIST:
-    if (c==0) printf("\t; %d",(int)code[++pc]);
-    else printf("\t; %d",c);
-    break;
-   default:
-    break;
-  }
-  printf("\n");
- }
-}
-
-#define SS(x)  (x==1)?"":"s"
-#define S(x)   x,SS(x)
-
-static void PrintHeader(const Proto* f)
-{
- const char* s=getstr(f->source);
- if (*s=='@' || *s=='=')
-  s++;
- else if (*s==LUA_SIGNATURE[0])
-  s="(bstring)";
- else
-  s="(string)";
- printf("\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %p)\n",
-       (f->linedefined==0)?"main":"function",s,
-       f->linedefined,f->lastlinedefined,
-       S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));
- printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
-       f->numparams,f->is_vararg?"+":"",SS(f->numparams),
-       S(f->maxstacksize),S(f->nups));
- printf("%d local%s, %d constant%s, %d function%s\n",
-       S(f->sizelocvars),S(f->sizek),S(f->sizep));
-}
-
-static void PrintConstants(const Proto* f)
-{
- int i,n=f->sizek;
- printf("constants (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t",i+1);
-  PrintConstant(f,i);
-  printf("\n");
- }
-}
-
-static void PrintLocals(const Proto* f)
-{
- int i,n=f->sizelocvars;
- printf("locals (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
- }
-}
-
-static void PrintUpvalues(const Proto* f)
-{
- int i,n=f->sizeupvalues;
- printf("upvalues (%d) for %p:\n",n,VOID(f));
- if (f->upvalues==NULL) return;
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\n",i,getstr(f->upvalues[i]));
- }
-}
-
-void PrintFunction(const Proto* f, int full)
-{
- int i,n=f->sizep;
- PrintHeader(f);
- PrintCode(f);
- if (full)
- {
-  PrintConstants(f);
-  PrintLocals(f);
-  PrintUpvalues(f);
- }
- for (i=0; i<n; i++) PrintFunction(f->p[i],full);
-}

diff --git a/source3/lua-5.1.4/test/README b/source3/lua-5.1.4/test/README
deleted file mode 100644 (file)
index baf7583..0000000
--- a/source3/lua-5.1.4/test/README
+++ /dev/null
@@ -1,25 +0,0 @@
-These are simple tests for Lua.  Some of them contain useful code.
-They are meant to be run to make sure Lua is built correctly and also
-to be read, to see how Lua programs look.
-
-Here is a one-line summary of each program:
-
-   bisect.lua          bisection method for solving non-linear equations
-   cf.lua              temperature conversion table (celsius to farenheit)
-   echo.lua             echo command line arguments
-   env.lua              environment variables as automatic global variables
-   factorial.lua       factorial without recursion
-   fib.lua             fibonacci function with cache
-   fibfor.lua          fibonacci numbers with coroutines and generators
-   globals.lua         report global variable usage
-   hello.lua           the first program in every language
-   life.lua            Conway's Game of Life
-   luac.lua            bare-bones luac
-   printf.lua          an implementation of printf
-   readonly.lua                make global variables readonly
-   sieve.lua           the sieve of of Eratosthenes programmed with coroutines
-   sort.lua            two implementations of a sort function
-   table.lua           make table, grouping all data for the same item
-   trace-calls.lua     trace calls
-   trace-globals.lua   trace assigments to global variables
-   xd.lua              hex dump

diff --git a/source3/lua-5.1.4/test/bisect.lua b/source3/lua-5.1.4/test/bisect.lua
deleted file mode 100644 (file)
index f91e69b..0000000
--- a/source3/lua-5.1.4/test/bisect.lua
+++ /dev/null
@@ -1,27 +0,0 @@
--- bisection method for solving non-linear equations
-
-delta=1e-6     -- tolerance
-
-function bisect(f,a,b,fa,fb)
- local c=(a+b)/2
- io.write(n," c=",c," a=",a," b=",b,"\n")
- if c==a or c==b or math.abs(a-b)<delta then return c,b-a end
- n=n+1
- local fc=f(c)
- if fa*fc<0 then return bisect(f,a,c,fa,fc) else return bisect(f,c,b,fc,fb) end
-end
-
--- find root of f in the inverval [a,b]. needs f(a)*f(b)<0
-function solve(f,a,b)
- n=0
- local z,e=bisect(f,a,b,f(a),f(b))
- io.write(string.format("after %d steps, root is %.17g with error %.1e, f=%.1e\n",n,z,e,f(z)))
-end
-
--- our function
-function f(x)
- return x*x*x-x-1
-end
-
--- find zero in [1,2]
-solve(f,1,2)

diff --git a/source3/lua-5.1.4/test/cf.lua b/source3/lua-5.1.4/test/cf.lua
deleted file mode 100644 (file)
index 2b2880d..0000000
--- a/source3/lua-5.1.4/test/cf.lua
+++ /dev/null
@@ -1,16 +0,0 @@
--- temperature conversion table (celsius to farenheit)
-
-for c0=-20,50-1,10 do
-       io.write("C ")
-       for c=c0,c0+10-1 do
-               io.write(string.format("%3.0f ",c))
-       end
-       io.write("\n")
-
-       io.write("F ")
-       for c=c0,c0+10-1 do
-               f=(9/5)*c+32
-               io.write(string.format("%3.0f ",f))
-       end
-       io.write("\n\n")
-end

diff --git a/source3/lua-5.1.4/test/echo.lua b/source3/lua-5.1.4/test/echo.lua
deleted file mode 100644 (file)
index 4313439..0000000
--- a/source3/lua-5.1.4/test/echo.lua
+++ /dev/null
@@ -1,5 +0,0 @@
--- echo command line arguments
-
-for i=0,table.getn(arg) do
- print(i,arg[i])
-end

diff --git a/source3/lua-5.1.4/test/env.lua b/source3/lua-5.1.4/test/env.lua
deleted file mode 100644 (file)
index 9e62a57..0000000
--- a/source3/lua-5.1.4/test/env.lua
+++ /dev/null
@@ -1,7 +0,0 @@
--- read environment variables as if they were global variables
-
-local f=function (t,i) return os.getenv(i) end
-setmetatable(getfenv(),{__index=f})
-
--- an example
-print(a,USER,PATH)

diff --git a/source3/lua-5.1.4/test/factorial.lua b/source3/lua-5.1.4/test/factorial.lua
deleted file mode 100644 (file)
index 7c4cf0f..0000000
--- a/source3/lua-5.1.4/test/factorial.lua
+++ /dev/null
@@ -1,32 +0,0 @@
--- function closures are powerful
-
--- traditional fixed-point operator from functional programming
-Y = function (g)
-      local a = function (f) return f(f) end
-      return a(function (f)
-                 return g(function (x)
-                             local c=f(f)
-                             return c(x)
-                           end)
-               end)
-end
-
-
--- factorial without recursion
-F = function (f)
-      return function (n)
-               if n == 0 then return 1
-               else return n*f(n-1) end
-             end
-    end
-
-factorial = Y(F)   -- factorial is the fixed point of F
-
--- now test it
-function test(x)
-       io.write(x,"! = ",factorial(x),"\n")
-end
-
-for n=0,16 do
-       test(n)
-end

diff --git a/source3/lua-5.1.4/test/fib.lua b/source3/lua-5.1.4/test/fib.lua
deleted file mode 100644 (file)
index 97a921b..0000000
--- a/source3/lua-5.1.4/test/fib.lua
+++ /dev/null
@@ -1,40 +0,0 @@
--- fibonacci function with cache
-
--- very inefficient fibonacci function
-function fib(n)
-       N=N+1
-       if n<2 then
-               return n
-       else
-               return fib(n-1)+fib(n-2)
-       end
-end
-
--- a general-purpose value cache
-function cache(f)
-       local c={}
-       return function (x)
-               local y=c[x]
-               if not y then
-                       y=f(x)
-                       c[x]=y
-               end
-               return y
-       end
-end
-
--- run and time it
-function test(s,f)
-       N=0
-       local c=os.clock()
-       local v=f(n)
-       local t=os.clock()-c
-       print(s,n,v,t,N)
-end
-
-n=arg[1] or 24         -- for other values, do lua fib.lua XX
-n=tonumber(n)
-print("","n","value","time","evals")
-test("plain",fib)
-fib=cache(fib)
-test("cached",fib)

diff --git a/source3/lua-5.1.4/test/fibfor.lua b/source3/lua-5.1.4/test/fibfor.lua
deleted file mode 100644 (file)
index 8bbba39..0000000
--- a/source3/lua-5.1.4/test/fibfor.lua
+++ /dev/null
@@ -1,13 +0,0 @@
--- example of for with generator functions
-
-function generatefib (n)
-  return coroutine.wrap(function ()
-    local a,b = 1, 1
-    while a <= n do
-      coroutine.yield(a)
-      a, b = b, a+b
-    end
-  end)
-end
-
-for i in generatefib(1000) do print(i) end

diff --git a/source3/lua-5.1.4/test/globals.lua b/source3/lua-5.1.4/test/globals.lua
deleted file mode 100644 (file)
index d4c20e1..0000000
--- a/source3/lua-5.1.4/test/globals.lua
+++ /dev/null
@@ -1,13 +0,0 @@
--- reads luac listings and reports global variable usage
--- lines where a global is written to are marked with "*"
--- typical usage: luac -p -l file.lua | lua globals.lua | sort | lua table.lua
-
-while 1 do
- local s=io.read()
- if s==nil then break end
- local ok,_,l,op,g=string.find(s,"%[%-?(%d*)%]%s*([GS])ETGLOBAL.-;%s+(.*)$")
- if ok then
-  if op=="S" then op="*" else op="" end
-  io.write(g,"\t",l,op,"\n")
- end
-end

diff --git a/source3/lua-5.1.4/test/hello.lua b/source3/lua-5.1.4/test/hello.lua
deleted file mode 100644 (file)
index 0925498..0000000
--- a/source3/lua-5.1.4/test/hello.lua
+++ /dev/null
@@ -1,3 +0,0 @@
--- the first program in every language
-
-io.write("Hello world, from ",_VERSION,"!\n")

diff --git a/source3/lua-5.1.4/test/life.lua b/source3/lua-5.1.4/test/life.lua
deleted file mode 100644 (file)
index 911d9fe..0000000
--- a/source3/lua-5.1.4/test/life.lua
+++ /dev/null
@@ -1,111 +0,0 @@
--- life.lua
--- original by Dave Bollinger <DBollinger@compuserve.com> posted to lua-l
--- modified to use ANSI terminal escape sequences
--- modified to use for instead of while
-
-local write=io.write
-
-ALIVE="¥"      DEAD="þ"
-ALIVE="O"      DEAD="-"
-
-function delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary
-  for i=1,10000 do end
-  -- local i=os.clock()+1 while(os.clock()<i) do end
-end
-
-function ARRAY2D(w,h)
-  local t = {w=w,h=h}
-  for y=1,h do
-    t[y] = {}
-    for x=1,w do
-      t[y][x]=0
-    end
-  end
-  return t
-end
-
-_CELLS = {}
-
--- give birth to a "shape" within the cell array
-function _CELLS:spawn(shape,left,top)
-  for y=0,shape.h-1 do
-    for x=0,shape.w-1 do
-      self[top+y][left+x] = shape[y*shape.w+x+1]
-    end
-  end
-end
-
--- run the CA and produce the next generation
-function _CELLS:evolve(next)
-  local ym1,y,yp1,yi=self.h-1,self.h,1,self.h
-  while yi > 0 do
-    local xm1,x,xp1,xi=self.w-1,self.w,1,self.w
-    while xi > 0 do
-      local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] +
-                  self[y][xm1] + self[y][xp1] +
-                  self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]
-      next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0
-      xm1,x,xp1,xi = x,xp1,xp1+1,xi-1
-    end
-    ym1,y,yp1,yi = y,yp1,yp1+1,yi-1
-  end
-end
-
--- output the array to screen
-function _CELLS:draw()
-  local out="" -- accumulate to reduce flicker
-  for y=1,self.h do
-   for x=1,self.w do
-      out=out..(((self[y][x]>0) and ALIVE) or DEAD)
-    end
-    out=out.."\n"
-  end
-  write(out)
-end
-
--- constructor
-function CELLS(w,h)
-  local c = ARRAY2D(w,h)
-  c.spawn = _CELLS.spawn
-  c.evolve = _CELLS.evolve
-  c.draw = _CELLS.draw
-  return c
-end
-
---
--- shapes suitable for use with spawn() above
---
-HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }
-GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }
-EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }
-FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }
-BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }
-
--- the main routine
-function LIFE(w,h)
-  -- create two arrays
-  local thisgen = CELLS(w,h)
-  local nextgen = CELLS(w,h)
-
-  -- create some life
-  -- about 1000 generations of fun, then a glider steady-state
-  thisgen:spawn(GLIDER,5,4)
-  thisgen:spawn(EXPLODE,25,10)
-  thisgen:spawn(FISH,4,12)
-
-  -- run until break
-  local gen=1
-  write("\027[2J")     -- ANSI clear screen
-  while 1 do
-    thisgen:evolve(nextgen)
-    thisgen,nextgen = nextgen,thisgen
-    write("\027[H")    -- ANSI home cursor
-    thisgen:draw()
-    write("Life - generation ",gen,"\n")
-    gen=gen+1
-    if gen>2000 then break end
-    --delay()          -- no delay
-  end
-end
-
-LIFE(40,20)

diff --git a/source3/lua-5.1.4/test/luac.lua b/source3/lua-5.1.4/test/luac.lua
deleted file mode 100644 (file)
index 96a0a97..0000000
--- a/source3/lua-5.1.4/test/luac.lua
+++ /dev/null
@@ -1,7 +0,0 @@
--- bare-bones luac in Lua
--- usage: lua luac.lua file.lua
-
-assert(arg[1]~=nil and arg[2]==nil,"usage: lua luac.lua file.lua")
-f=assert(io.open("luac.out","wb"))
-assert(f:write(string.dump(assert(loadfile(arg[1])))))
-assert(f:close())

diff --git a/source3/lua-5.1.4/test/printf.lua b/source3/lua-5.1.4/test/printf.lua
deleted file mode 100644 (file)
index 58c63ff..0000000
--- a/source3/lua-5.1.4/test/printf.lua
+++ /dev/null
@@ -1,7 +0,0 @@
--- an implementation of printf
-
-function printf(...)
- io.write(string.format(...))
-end
-
-printf("Hello %s from %s on %s\n",os.getenv"USER" or "there",_VERSION,os.date())

diff --git a/source3/lua-5.1.4/test/readonly.lua b/source3/lua-5.1.4/test/readonly.lua
deleted file mode 100644 (file)
index 85c0b4e..0000000
--- a/source3/lua-5.1.4/test/readonly.lua
+++ /dev/null
@@ -1,12 +0,0 @@
--- make global variables readonly
-
-local f=function (t,i) error("cannot redefine global variable `"..i.."'",2) end
-local g={}
-local G=getfenv()
-setmetatable(g,{__index=G,__newindex=f})
-setfenv(1,g)
-
--- an example
-rawset(g,"x",3)
-x=2
-y=1    -- cannot redefine `y'

diff --git a/source3/lua-5.1.4/test/sieve.lua b/source3/lua-5.1.4/test/sieve.lua
deleted file mode 100644 (file)
index 0871bb2..0000000
--- a/source3/lua-5.1.4/test/sieve.lua
+++ /dev/null
@@ -1,29 +0,0 @@
--- the sieve of of Eratosthenes programmed with coroutines
--- typical usage: lua -e N=1000 sieve.lua | column
-
--- generate all the numbers from 2 to n
-function gen (n)
-  return coroutine.wrap(function ()
-    for i=2,n do coroutine.yield(i) end
-  end)
-end
-
--- filter the numbers generated by `g', removing multiples of `p'
-function filter (p, g)
-  return coroutine.wrap(function ()
-    while 1 do
-      local n = g()
-      if n == nil then return end
-      if math.mod(n, p) ~= 0 then coroutine.yield(n) end
-    end
-  end)
-end
-
-N=N or 1000            -- from command line
-x = gen(N)             -- generate primes up to N
-while 1 do
-  local n = x()                -- pick a number until done
-  if n == nil then break end
-  print(n)             -- must be a prime number
-  x = filter(n, x)     -- now remove its multiples
-end

diff --git a/source3/lua-5.1.4/test/sort.lua b/source3/lua-5.1.4/test/sort.lua
deleted file mode 100644 (file)
index 0bcb15f..0000000
--- a/source3/lua-5.1.4/test/sort.lua
+++ /dev/null
@@ -1,66 +0,0 @@
--- two implementations of a sort function
--- this is an example only. Lua has now a built-in function "sort"
-
--- extracted from Programming Pearls, page 110
-function qsort(x,l,u,f)
- if l<u then
-  local m=math.random(u-(l-1))+l-1     -- choose a random pivot in range l..u
-  x[l],x[m]=x[m],x[l]                  -- swap pivot to first position
-  local t=x[l]                         -- pivot value
-  m=l
-  local i=l+1
-  while i<=u do
-    -- invariant: x[l+1..m] < t <= x[m+1..i-1]
-    if f(x[i],t) then
-      m=m+1
-      x[m],x[i]=x[i],x[m]              -- swap x[i] and x[m]
-    end
-    i=i+1
-  end
-  x[l],x[m]=x[m],x[l]                  -- swap pivot to a valid place
-  -- x[l+1..m-1] < x[m] <= x[m+1..u]
-  qsort(x,l,m-1,f)
-  qsort(x,m+1,u,f)
- end
-end
-
-function selectionsort(x,n,f)
- local i=1
- while i<=n do
-  local m,j=i,i+1
-  while j<=n do
-   if f(x[j],x[m]) then m=j end
-   j=j+1
-  end
- x[i],x[m]=x[m],x[i]                   -- swap x[i] and x[m]
- i=i+1
- end
-end
-
-function show(m,x)
- io.write(m,"\n\t")
- local i=1
- while x[i] do
-  io.write(x[i])
-  i=i+1
-  if x[i] then io.write(",") end
- end
- io.write("\n")
-end
-
-function testsorts(x)
- local n=1
- while x[n] do n=n+1 end; n=n-1                -- count elements
- show("original",x)
- qsort(x,1,n,function (x,y) return x<y end)
- show("after quicksort",x)
- selectionsort(x,n,function (x,y) return x>y end)
- show("after reverse selection sort",x)
- qsort(x,1,n,function (x,y) return x<y end)
- show("after quicksort again",x)
-end
-
--- array to be sorted
-x={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}
-
-testsorts(x)

diff --git a/source3/lua-5.1.4/test/table.lua b/source3/lua-5.1.4/test/table.lua
deleted file mode 100644 (file)
index 235089c..0000000
--- a/source3/lua-5.1.4/test/table.lua
+++ /dev/null
@@ -1,12 +0,0 @@
--- make table, grouping all data for the same item
--- input is 2 columns (item, data)
-
-local A
-while 1 do
- local l=io.read()
- if l==nil then break end
- local _,_,a,b=string.find(l,'"?([_%w]+)"?%s*(.*)$')
- if a~=A then A=a io.write("\n",a,":") end
- io.write(" ",b)
-end
-io.write("\n")

diff --git a/source3/lua-5.1.4/test/trace-calls.lua b/source3/lua-5.1.4/test/trace-calls.lua
deleted file mode 100644 (file)
index 6d7a7b3..0000000
--- a/source3/lua-5.1.4/test/trace-calls.lua
+++ /dev/null
@@ -1,32 +0,0 @@
--- trace calls
--- example: lua -ltrace-calls bisect.lua
-
-local level=0
-
-local function hook(event)
- local t=debug.getinfo(3)
- io.write(level," >>> ",string.rep(" ",level))
- if t~=nil and t.currentline>=0 then io.write(t.short_src,":",t.currentline," ") end
- t=debug.getinfo(2)
- if event=="call" then
-  level=level+1
- else
-  level=level-1 if level<0 then level=0 end
- end
- if t.what=="main" then
-  if event=="call" then
-   io.write("begin ",t.short_src)
-  else
-   io.write("end ",t.short_src)
-  end
- elseif t.what=="Lua" then
--- table.foreach(t,print)
-  io.write(event," ",t.name or "(Lua)"," <",t.linedefined,":",t.short_src,">")
- else
- io.write(event," ",t.name or "(C)"," [",t.what,"] ")
- end
- io.write("\n")
-end
-
-debug.sethook(hook,"cr")
-level=0

diff --git a/source3/lua-5.1.4/test/trace-globals.lua b/source3/lua-5.1.4/test/trace-globals.lua
deleted file mode 100644 (file)
index 295e670..0000000
--- a/source3/lua-5.1.4/test/trace-globals.lua
+++ /dev/null
@@ -1,38 +0,0 @@
--- trace assigments to global variables
-
-do
- -- a tostring that quotes strings. note the use of the original tostring.
- local _tostring=tostring
- local tostring=function(a)
-  if type(a)=="string" then
-   return string.format("%q",a)
-  else
-   return _tostring(a)
-  end
- end
-
- local log=function (name,old,new)
-  local t=debug.getinfo(3,"Sl")
-  local line=t.currentline
-  io.write(t.short_src)
-  if line>=0 then io.write(":",line) end
-  io.write(": ",name," is now ",tostring(new)," (was ",tostring(old),")","\n")
- end
-
- local g={}
- local set=function (t,name,value)
-  log(name,g[name],value)
-  g[name]=value
- end
- setmetatable(getfenv(),{__index=g,__newindex=set})
-end
-
--- an example
-
-a=1
-b=2
-a=10
-b=20
-b=nil
-b=200
-print(a,b,c)

diff --git a/source3/lua-5.1.4/test/xd.lua b/source3/lua-5.1.4/test/xd.lua
deleted file mode 100644 (file)
index d447ae6..0000000
--- a/source3/lua-5.1.4/test/xd.lua
+++ /dev/null
@@ -1,14 +0,0 @@
--- hex dump
--- usage: lua xd.lua < file
-
-local offset=0
-while true do
- local s=io.read(16)
- if s==nil then return end
- io.write(string.format("%08X  ",offset))
- string.gsub(s,"(.)",
-       function (c) io.write(string.format("%02X ",string.byte(c))) end)
- io.write(string.rep(" ",3*(16-string.len(s))))
- io.write(" ",string.gsub(s,"%c","."),"\n")
- offset=offset+16
-end

diff --git a/source3/modules/nfs4_acls.c b/source3/modules/nfs4_acls.c
index cf96061ea632d8101f3908f0077689a1c0ea1e6d..658f2b4e8de877ebb0120a587d4a4d2fa9cc8de7 100644 (file)
--- a/source3/modules/nfs4_acls.c
+++ b/source3/modules/nfs4_acls.c
@@ -170,7 +170,7 @@ static int smbacl4_GetFileOwner(struct connection_struct *conn,
        /* Get the stat struct for the owner info. */
        if (vfs_stat_smb_fname(conn, filename, psbuf) != 0)
        {
-               DEBUG(8, ("SMB_VFS_STAT failed with error %s\n",
+               DEBUG(8, ("vfs_stat_smb_fname failed with error %s\n",
                        strerror(errno)));
                return -1;
        }

diff --git a/source3/modules/onefs_open.c b/source3/modules/onefs_open.c
index b9a2c30734cc7e0b94476324dec9ca7e6db6d092..d90f165cd7627ccc5805936f9e46d8934059e9aa 100644 (file)
--- a/source3/modules/onefs_open.c
+++ b/source3/modules/onefs_open.c
@@ -1253,7 +1253,7 @@ NTSTATUS onefs_open_file_ntcreate(connection_struct *conn,
           note that GPFS supports it as well - jmcd */
 
        if (fsp->fh->fd != -1) {
-               ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access);
+               ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
                if(ret_flock == -1 ){
 
                        TALLOC_FREE(lck);

diff --git a/source3/modules/vfs_acl_common.c b/source3/modules/vfs_acl_common.c
index 5fdd2b4725c0b7f61e6ccae8e8bbb6177c7d626d..39fd2ad0ed881170fd7aae757c12c772a2128b83 100644 (file)
--- a/source3/modules/vfs_acl_common.c
+++ b/source3/modules/vfs_acl_common.c
@@ -380,21 +380,26 @@ static NTSTATUS inherit_new_acl(vfs_handle_struct *handle,
        }
 
        if (!psd || psd->dacl == NULL) {
-               int ret;
 
                TALLOC_FREE(psd);
-               if (fsp && !fsp->is_directory && fsp->fh->fd != -1) {
-                       ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
+               if (fsp) {
+                       status = vfs_stat_fsp(fsp);
+                       smb_fname->st = fsp->fsp_name->st;
                } else {
-                       if (fsp && fsp->posix_open) {
+                       int ret;
+                       if (lp_posix_pathnames()) {
                                ret = SMB_VFS_LSTAT(handle->conn, smb_fname);
                        } else {
                                ret = SMB_VFS_STAT(handle->conn, smb_fname);
                        }
+                       if (ret == -1) {
+                               status = map_nt_error_from_unix(errno);
+                       }
                }
-               if (ret == -1) {
-                       return map_nt_error_from_unix(errno);
+               if (!NT_STATUS_IS_OK(status)) {
+                       return status;
                }
+
                psd = default_file_sd(ctx, &smb_fname->st);
                if (!psd) {
                        return NT_STATUS_NO_MEMORY;
@@ -580,23 +585,14 @@ static NTSTATUS fset_nt_acl_common(vfs_handle_struct *handle, files_struct *fsp,
 
        /* Ensure owner and group are set. */
        if (!psd->owner_sid || !psd->group_sid) {
-               int ret;
                DOM_SID owner_sid, group_sid;
                struct security_descriptor *nc_psd = dup_sec_desc(talloc_tos(), psd);
 
                if (!nc_psd) {
                        return NT_STATUS_OK;
                }
-               if (fsp->is_directory || fsp->fh->fd == -1) {
-                       if (fsp->posix_open) {
-                               ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
-                       } else {
-                               ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
-                       }
-               } else {
-                       ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
-               }
-               if (ret == -1) {
+               status = vfs_stat_fsp(fsp);
+               if (!NT_STATUS_IS_OK(status)) {
                        /* Lower level acl set succeeded,
                         * so still return OK. */
                        return NT_STATUS_OK;

diff --git a/source3/modules/vfs_acl_tdb.c b/source3/modules/vfs_acl_tdb.c
index 285c58ed9d19f00731d1d11f7c6400963912c6ff..424ecbf65b80c4af7489b0d18c58593c6e8b2731 100644 (file)
--- a/source3/modules/vfs_acl_tdb.c
+++ b/source3/modules/vfs_acl_tdb.c
@@ -147,24 +147,26 @@ static NTSTATUS get_acl_blob(TALLOC_CTX *ctx,
        TDB_DATA data;
        struct file_id id;
        struct db_context *db;
-       int ret = -1;
+       NTSTATUS status;
        SMB_STRUCT_STAT sbuf;
 
        SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context,
                return NT_STATUS_INTERNAL_DB_CORRUPTION);
 
-       if (fsp && fsp->fh->fd != -1) {
-               ret = SMB_VFS_FSTAT(fsp, &sbuf);
+       ZERO_STRUCT(sbuf);
+
+       if (fsp) {
+               status = vfs_stat_fsp(fsp);
+               sbuf = fsp->fsp_name->st;
        } else {
-               if (fsp && fsp->posix_open) {
-                       ret = vfs_lstat_smb_fname(handle->conn, name, &sbuf);
-               } else {
-                       ret = vfs_stat_smb_fname(handle->conn, name, &sbuf);
+               int ret = vfs_stat_smb_fname(handle->conn, name, &sbuf);
+               if (ret == -1) {
+                       status = map_nt_error_from_unix(errno);
                }
        }
 
-       if (ret == -1) {
-               return map_nt_error_from_unix(errno);
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
        }
 
        id = vfs_file_id_from_sbuf(handle->conn, &sbuf);
@@ -204,7 +206,7 @@ static NTSTATUS store_acl_blob_fsp(vfs_handle_struct *handle,
        TDB_DATA data;
        struct db_context *db;
        struct db_record *rec;
-       int ret = -1;
+       NTSTATUS status;
 
        DEBUG(10,("store_acl_blob_fsp: storing blob length %u on file %s\n",
                  (unsigned int)pblob->length, fsp_str_dbg(fsp)));
@@ -212,18 +214,9 @@ static NTSTATUS store_acl_blob_fsp(vfs_handle_struct *handle,
        SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context,
                return NT_STATUS_INTERNAL_DB_CORRUPTION);
 
-       if (fsp->fh->fd != -1) {
-               ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
-       } else {
-               if (fsp->posix_open) {
-                       ret = SMB_VFS_LSTAT(handle->conn, fsp->fsp_name);
-               } else {
-                       ret = SMB_VFS_STAT(handle->conn, fsp->fsp_name);
-               }
-       }
-
-       if (ret == -1) {
-               return map_nt_error_from_unix(errno);
+       status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
        }
 
        id = vfs_file_id_from_sbuf(handle->conn, &fsp->fsp_name->st);
@@ -438,20 +431,13 @@ static int sys_acl_set_fd_tdb(vfs_handle_struct *handle,
                             SMB_ACL_T theacl)
 {
        struct db_context *db;
+       NTSTATUS status;
        int ret;
 
        SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
 
-       if (fsp->is_directory || fsp->fh->fd == -1) {
-               if (fsp->posix_open) {
-                       ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
-               } else {
-                       ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
-               }
-       } else {
-               ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
-       }
-       if (ret == -1) {
+       status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(status)) {
                return -1;
        }
 

diff --git a/source3/modules/vfs_afsacl.c b/source3/modules/vfs_afsacl.c
index 1c310c7185983dc6bb3db02125ddccaf4b731181..4666be2aa31a5a25c9084586f0417ca71aee8e3a 100644 (file)
--- a/source3/modules/vfs_afsacl.c
+++ b/source3/modules/vfs_afsacl.c
@@ -659,8 +659,15 @@ static size_t afs_to_nt_acl(struct afs_acl *afs_acl,
                            uint32 security_info,
                            struct security_descriptor **ppdesc)
 {
+       int ret;
+
        /* Get the stat struct for the owner info. */
-       if(SMB_VFS_STAT(conn, smb_fname) != 0) {
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LSTAT(conn, smb_fname);
+       } else {
+               ret = SMB_VFS_STAT(conn, smb_fname);
+       }
+       if (ret == -1) {
                return 0;
        }
 

diff --git a/source3/modules/vfs_default.c b/source3/modules/vfs_default.c
index c92bc8ec21a0e3360a291917a66700b54d43c1fc..036a4380025bc1e314140575734b34eb572b9b0f 100644 (file)
--- a/source3/modules/vfs_default.c
+++ b/source3/modules/vfs_default.c
@@ -1057,10 +1057,10 @@ static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, S
 }
 
 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
-                               uint32 share_mode)
+                               uint32 share_mode, uint32 access_mask)
 {
        START_PROFILE(syscall_kernel_flock);
-       kernel_flock(fsp->fh->fd, share_mode);
+       kernel_flock(fsp->fh->fd, share_mode, access_mask);
        END_PROFILE(syscall_kernel_flock);
        return 0;
 }
@@ -1231,7 +1231,11 @@ static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
                if (!NT_STATUS_IS_OK(status)) {
                        return status;
                }
-               ret = SMB_VFS_STAT(handle->conn, smb_fname);
+               if (lp_posix_pathnames()) {
+                       ret = SMB_VFS_LSTAT(handle->conn, smb_fname);
+               } else {
+                       ret = SMB_VFS_STAT(handle->conn, smb_fname);
+               }
                sbuf = smb_fname->st;
                TALLOC_FREE(smb_fname);
        }

diff --git a/source3/modules/vfs_full_audit.c b/source3/modules/vfs_full_audit.c
index 22abee416ca0c8db67453d75a90802e2c316f33a..5305af48324418da5d4e5d285209a65b699dacb9 100644 (file)
--- a/source3/modules/vfs_full_audit.c
+++ b/source3/modules/vfs_full_audit.c
@@ -1245,11 +1245,11 @@ static bool smb_full_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
 
 static int smb_full_audit_kernel_flock(struct vfs_handle_struct *handle,
                                       struct files_struct *fsp,
-                                      uint32 share_mode)
+                                      uint32 share_mode, uint32 access_mask)
 {
        int result;
 
-       result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode);
+       result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask);
 
        do_log(SMB_VFS_OP_KERNEL_FLOCK, (result >= 0), handle, "%s",
               fsp_str_do_log(fsp));

diff --git a/source3/modules/vfs_gpfs.c b/source3/modules/vfs_gpfs.c
index c1131a92b92e9f283ecc2cc3ab56c868721f0b7b..7c481d6ba0f602fa5e14a169266cb6201f43383c 100644 (file)
--- a/source3/modules/vfs_gpfs.c
+++ b/source3/modules/vfs_gpfs.c
@@ -31,14 +31,14 @@
 #include "vfs_gpfs.h"
 
 static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, 
-                                uint32 share_mode)
+                                uint32 share_mode, uint32 access_mask)
 {
 
        START_PROFILE(syscall_kernel_flock);
 
-       kernel_flock(fsp->fh->fd, share_mode);
+       kernel_flock(fsp->fh->fd, share_mode, access_mask);
 
-       if (!set_gpfs_sharemode(fsp, fsp->access_mask, fsp->share_access)) {
+       if (!set_gpfs_sharemode(fsp, access_mask, fsp->share_access)) {
 
                return -1;
 

diff --git a/source3/modules/vfs_hpuxacl.c b/source3/modules/vfs_hpuxacl.c
index df70f1ea08c22c3cce5ce77b34d96a5297490f8f..5a54f79da360f556b6d8146030bde0ed1b6fb7fa 100644 (file)
--- a/source3/modules/vfs_hpuxacl.c
+++ b/source3/modules/vfs_hpuxacl.c
@@ -255,7 +255,12 @@ int hpuxacl_sys_acl_set_file(vfs_handle_struct *handle,
         * that has _not_ been specified in "type" from the file first 
         * and concatenate it with the acl provided.
         */
-       if (SMB_VFS_STAT(handle->conn, smb_fname) != 0) {
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LSTAT(handle->conn, smb_fname);
+       } else {
+               ret = SMB_VFS_STAT(handle->conn, smb_fname);
+       }
+       if (ret != 0) {
                DEBUG(10, ("Error in stat call: %s\n", strerror(errno)));
                goto done;
        }

diff --git a/source3/modules/vfs_shadow_copy2.c b/source3/modules/vfs_shadow_copy2.c
index eac83fca7499e01d7be883a0ecbe953919aee2f7..61f71b7bbc6a48c0bc898c0a1ee87471b070e662 100644 (file)
--- a/source3/modules/vfs_shadow_copy2.c
+++ b/source3/modules/vfs_shadow_copy2.c
@@ -76,31 +76,99 @@ static int vfs_shadow_copy2_debug_level = DBGC_VFS;
 /*
   make very sure it is one of our special names 
  */
-static inline bool shadow_copy2_match_name(const char *name)
+static inline bool shadow_copy2_match_name(const char *name, const char **gmt_start)
 {
        unsigned year, month, day, hr, min, sec;
-       if (name[0] != '@') return False;
-       if (strncmp(name, "@GMT-", 5) != 0) return False;
-       if (sscanf(name, "@GMT-%04u.%02u.%02u-%02u.%02u.%02u", &year, &month,
+       const char *p;
+       if (gmt_start) {
+               (*gmt_start) = NULL;
+       }
+       p = strstr_m(name, "@GMT-");
+       if (p == NULL) return false;
+       if (p > name && p[-1] != '/') return False;
+       if (sscanf(p, "@GMT-%04u.%02u.%02u-%02u.%02u.%02u", &year, &month,
                   &day, &hr, &min, &sec) != 6) {
                return False;
        }
-       if (name[24] != 0 && name[24] != '/') {
+       if (p[24] != 0 && p[24] != '/') {
                return False;
        }
+       if (gmt_start) {
+               (*gmt_start) = p;
+       }
        return True;
 }
 
+/*
+  shadow copy paths can also come into the server in this form:
+
+    /foo/bar/@GMT-XXXXX/some/file
+
+  This function normalises the filename to be of the form:
+
+    @GMT-XXXX/foo/bar/some/file
+ */
+static const char *shadow_copy2_normalise_path(TALLOC_CTX *mem_ctx, const char *path, const char *gmt_start)
+{
+       char *pcopy;
+       char buf[GMT_NAME_LEN];
+       size_t prefix_len;
+
+       if (path == gmt_start) {
+               return path;
+       }
+
+       prefix_len = gmt_start - path - 1;
+
+       DEBUG(10, ("path=%s, gmt_start=%s, prefix_len=%d\n", path, gmt_start,
+                  (int)prefix_len));
+
+       /*
+        * We've got a/b/c/@GMT-YYYY.MM.DD-HH.MM.SS/d/e. convert to
+        * @GMT-YYYY.MM.DD-HH.MM.SS/a/b/c/d/e before further
+        * processing. As many VFS calls provide a const char *,
+        * unfortunately we have to make a copy.
+        */
+
+       pcopy = talloc_strdup(talloc_tos(), path);
+       if (pcopy == NULL) {
+               return NULL;
+       }
+
+       gmt_start = pcopy + prefix_len;
+
+       /*
+        * Copy away "@GMT-YYYY.MM.DD-HH.MM.SS"
+        */
+       memcpy(buf, gmt_start+1, GMT_NAME_LEN);
+
+       /*
+        * Make space for it including a trailing /
+        */
+       memmove(pcopy + GMT_NAME_LEN + 1, pcopy, prefix_len);
+
+       /*
+        * Move in "@GMT-YYYY.MM.DD-HH.MM.SS/" at the beginning again
+        */
+       memcpy(pcopy, buf, GMT_NAME_LEN);
+       pcopy[GMT_NAME_LEN] = '/';
+
+       DEBUG(10, ("shadow_copy2_normalise_path: %s -> %s\n", path, pcopy));
+
+       return pcopy;
+}
+
 /*
   convert a name to the shadow directory
  */
 
 #define _SHADOW2_NEXT(op, args, rtype, eret, extra) do { \
        const char *name = fname; \
-       if (shadow_copy2_match_name(fname)) { \
+       const char *gmt_start; \
+       if (shadow_copy2_match_name(fname, &gmt_start)) {       \
                char *name2; \
                rtype ret; \
-               name2 = convert_shadow2_name(handle, fname); \
+               name2 = convert_shadow2_name(handle, fname, gmt_start); \
                if (name2 == NULL) { \
                        errno = EINVAL; \
                        return eret; \
@@ -116,11 +184,12 @@ static inline bool shadow_copy2_match_name(const char *name)
 } while (0)
 
 #define _SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret, extra) do { \
-       if (shadow_copy2_match_name(smb_fname->base_name)) { \
+               const char *gmt_start; \
+               if (shadow_copy2_match_name(smb_fname->base_name, &gmt_start)) {        \
                char *name2; \
                char *smb_base_name_tmp = NULL; \
                rtype ret; \
-               name2 = convert_shadow2_name(handle, smb_fname->base_name); \
+               name2 = convert_shadow2_name(handle, smb_fname->base_name, gmt_start); \
                if (name2 == NULL) { \
                        errno = EINVAL; \
                        return eret; \
@@ -143,10 +212,11 @@ static inline bool shadow_copy2_match_name(const char *name)
 
 #define _SHADOW2_NTSTATUS_NEXT(op, args, eret, extra) do { \
         const char *name = fname; \
-        if (shadow_copy2_match_name(fname)) { \
+        const char *gmt_start; \
+        if (shadow_copy2_match_name(fname, &gmt_start)) {      \
                 char *name2; \
                 NTSTATUS ret; \
-                name2 = convert_shadow2_name(handle, fname); \
+                name2 = convert_shadow2_name(handle, fname, gmt_start);        \
                 if (name2 == NULL) { \
                         errno = EINVAL; \
                         return eret; \
@@ -168,7 +238,9 @@ static inline bool shadow_copy2_match_name(const char *name)
 #define SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret) _SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret, )
 
 #define SHADOW2_NEXT2(op, args) do { \
-       if (shadow_copy2_match_name(oldname) || shadow_copy2_match_name(newname)) { \
+       const char *gmt_start1, *gmt_start2; \
+       if (shadow_copy2_match_name(oldname, &gmt_start1) || \
+           shadow_copy2_match_name(newname, &gmt_start2)) {    \
                errno = EROFS; \
                return -1; \
        } else { \
@@ -177,8 +249,9 @@ static inline bool shadow_copy2_match_name(const char *name)
 } while (0)
 
 #define SHADOW2_NEXT2_SMB_FNAME(op, args) do { \
-       if (shadow_copy2_match_name(smb_fname_src->base_name) || \
-           shadow_copy2_match_name(smb_fname_dst->base_name)) { \
+       const char *gmt_start1, *gmt_start2; \
+       if (shadow_copy2_match_name(smb_fname_src->base_name, &gmt_start1) || \
+           shadow_copy2_match_name(smb_fname_dst->base_name, &gmt_start2)) { \
                errno = EROFS; \
                return -1; \
        } else { \
@@ -267,7 +340,7 @@ static const char *shadow_copy2_find_basedir(TALLOC_CTX *mem_ctx, vfs_handle_str
   convert a filename from a share relative path, to a path in the
   snapshot directory
  */
-static char *convert_shadow2_name(vfs_handle_struct *handle, const char *fname)
+static char *convert_shadow2_name(vfs_handle_struct *handle, const char *fname, const char *gmt_path)
 {
        TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
        const char *snapdir, *relpath, *baseoffset, *basedir;
@@ -288,6 +361,14 @@ static char *convert_shadow2_name(vfs_handle_struct *handle, const char *fname)
                return NULL;
        }
 
+       if (strncmp(fname, "@GMT-", 5) != 0) {
+               fname = shadow_copy2_normalise_path(tmp_ctx, fname, gmt_path);
+               if (fname == NULL) {
+                       talloc_free(tmp_ctx);
+                       return NULL;
+               }
+       }
+
        relpath = fname + GMT_NAME_LEN;
        baselen = strlen(basedir);
        baseoffset = handle->conn->connectpath + baselen;
@@ -406,7 +487,7 @@ static int shadow_copy2_lstat(vfs_handle_struct *handle,
 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 {
        int ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
-       if (ret == 0 && shadow_copy2_match_name(fsp->fsp_name->base_name)) {
+       if (ret == 0 && shadow_copy2_match_name(fsp->fsp_name->base_name, NULL)) {
                convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
        }
        return ret;
@@ -476,8 +557,24 @@ static int shadow_copy2_mknod(vfs_handle_struct *handle,
 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
                            const char *fname, char *resolved_path)
 {
-       if (shadow_copy2_match_name(fname) && (fname[GMT_NAME_LEN] == '\0')) {
-               return SMB_VFS_NEXT_REALPATH(handle, ".", resolved_path);
+       const char *gmt;
+
+       if (shadow_copy2_match_name(fname, &gmt)
+           && (gmt[GMT_NAME_LEN] == '\0')) {
+               char *copy, *result;
+
+               copy = talloc_strdup(talloc_tos(), fname);
+               if (copy == NULL) {
+                       errno = ENOMEM;
+                       return NULL;
+               }
+
+               copy[gmt - fname] = '.';
+
+               DEBUG(10, ("calling NEXT_REALPATH with %s\n", copy));
+               result = SMB_VFS_NEXT_REALPATH(handle, copy, resolved_path);
+               TALLOC_FREE(copy);
+               return result;
        }
         SHADOW2_NEXT(REALPATH, (handle, name, resolved_path), char *, NULL);
 }
@@ -486,14 +583,22 @@ static const char *shadow_copy2_connectpath(struct vfs_handle_struct *handle,
                                            const char *fname)
 {
        TALLOC_CTX *tmp_ctx = talloc_stackframe();
-       const char *snapdir, *baseoffset, *basedir;
+       const char *snapdir, *baseoffset, *basedir, *gmt_start;
        size_t baselen;
        char *ret;
 
-       if (!shadow_copy2_match_name(fname)) {
+       DEBUG(10, ("shadow_copy2_connectpath called with %s\n", fname));
+
+       if (!shadow_copy2_match_name(fname, &gmt_start)) {
                return handle->conn->connectpath;
        }
 
+       fname = shadow_copy2_normalise_path(talloc_tos(), fname, gmt_start);
+       if (fname == NULL) {
+               TALLOC_FREE(tmp_ctx);
+               return NULL;
+       }
+
        snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
        if (snapdir == NULL) {
                DEBUG(2,("no snapdir found for share at %s\n",
@@ -644,7 +749,7 @@ static int shadow_copy2_get_shadow_copy2_data(vfs_handle_struct *handle,
                SHADOW_COPY_LABEL *tlabels;
 
                /* ignore names not of the right form in the snapshot directory */
-               if (!shadow_copy2_match_name(d->d_name)) {
+               if (!shadow_copy2_match_name(d->d_name, NULL)) {
                        continue;
                }
 

diff --git a/source3/modules/vfs_streams_xattr.c b/source3/modules/vfs_streams_xattr.c
index b68fa02a354af98e4980108bd269e13e71327011..d7c0a834c0038b10db8f7efc659b4bd19b317edf 100644 (file)
--- a/source3/modules/vfs_streams_xattr.c
+++ b/source3/modules/vfs_streams_xattr.c
@@ -253,6 +253,11 @@ static int streams_xattr_stat(vfs_handle_struct *handle,
                return SMB_VFS_NEXT_STAT(handle, smb_fname);
        }
 
+       /* Note if lp_posix_paths() is true, we can never
+        * get here as is_ntfs_stream_smb_fname() is
+        * always false. So we never need worry about
+        * not following links here. */
+
        /* If the default stream is requested, just stat the base file. */
        if (is_ntfs_default_stream_smb_fname(smb_fname)) {
                return streams_xattr_stat_base(handle, smb_fname, true);
@@ -304,7 +309,7 @@ static int streams_xattr_lstat(vfs_handle_struct *handle,
                return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
        }
 
-               /* If the default stream is requested, just stat the base file. */
+       /* If the default stream is requested, just stat the base file. */
        if (is_ntfs_default_stream_smb_fname(smb_fname)) {
                return streams_xattr_stat_base(handle, smb_fname, false);
        }

diff --git a/source3/modules/vfs_xattr_tdb.c b/source3/modules/vfs_xattr_tdb.c
index 55fb1417b71f35348963c53f7e92c842539f5bce..f7fbfce4cb979f2232d9c301a78faab41996e5b1 100644 (file)
--- a/source3/modules/vfs_xattr_tdb.c
+++ b/source3/modules/vfs_xattr_tdb.c
@@ -630,9 +630,15 @@ static int xattr_tdb_unlink(vfs_handle_struct *handle,
                return -1;
        }
 
-       if (SMB_VFS_STAT(handle->conn, smb_fname_tmp) == -1) {
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LSTAT(handle->conn, smb_fname_tmp);
+       } else {
+               ret = SMB_VFS_STAT(handle->conn, smb_fname_tmp);
+       }
+       if (ret == -1) {
                goto out;
        }
+
        if (smb_fname_tmp->st.st_ex_nlink == 1) {
                /* Only remove record on last link to file. */
                remove_record = true;

diff --git a/source3/param/loadparm.c b/source3/param/loadparm.c
index b278b9616d0857cb0a4eaa43319d87737174cada..fa0577ba967015ebca320b8e43bdd745080b19f0 100644 (file)
--- a/source3/param/loadparm.c
+++ b/source3/param/loadparm.c
@@ -260,6 +260,7 @@ struct global {
        char *szLdapGroupSuffix;
        int ldap_ssl;
        bool ldap_ssl_ads;
+       int ldap_ref_follow;
        char *szLdapSuffix;
        char *szLdapAdminDn;
        int ldap_debug_level;
@@ -3274,6 +3275,8 @@ static struct parm_struct parm_table[] = {
                .type           = P_LIST,
                .p_class        = P_GLOBAL,
                .ptr            = &Globals.szInitLogonDelayedHosts,
+               .special        = NULL,
+               .enum_list      = NULL,
                .flags          = FLAG_ADVANCED,
        },
 
@@ -3282,6 +3285,8 @@ static struct parm_struct parm_table[] = {
                .type           = P_INTEGER,
                .p_class        = P_GLOBAL,
                .ptr            = &Globals.InitLogonDelay,
+               .special        = NULL,
+               .enum_list      = NULL,
                .flags          = FLAG_ADVANCED,
 
        },
@@ -3666,6 +3671,15 @@ static struct parm_struct parm_table[] = {
                .enum_list      = NULL,
                .flags          = FLAG_ADVANCED,
        },
+       {
+               .label          = "ldap ref follow",
+               .type           = P_ENUM,
+               .p_class        = P_GLOBAL,
+               .ptr            = &Globals.ldap_ref_follow,
+               .special        = NULL,
+               .enum_list      = enum_bool_auto,
+               .flags          = FLAG_ADVANCED,
+       },
        {
                .label          = "ldap timeout",
                .type           = P_INTEGER,
@@ -5038,6 +5052,7 @@ static void init_globals(bool first_time_only)
        Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
        Globals.ldap_delete_dn = False;
        Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
+       Globals.ldap_ref_follow = Auto;
        Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
        Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
        Globals.ldap_page_size = LDAP_PAGE_SIZE;
@@ -5387,6 +5402,7 @@ FN_GLOBAL_STRING(lp_ldap_suffix, &Globals.szLdapSuffix)
 FN_GLOBAL_STRING(lp_ldap_admin_dn, &Globals.szLdapAdminDn)
 FN_GLOBAL_INTEGER(lp_ldap_ssl, &Globals.ldap_ssl)
 FN_GLOBAL_BOOL(lp_ldap_ssl_ads, &Globals.ldap_ssl_ads)
+FN_GLOBAL_INTEGER(lp_ldap_ref_follow, &Globals.ldap_ref_follow)
 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, &Globals.ldap_passwd_sync)
 FN_GLOBAL_BOOL(lp_ldap_delete_dn, &Globals.ldap_delete_dn)
 FN_GLOBAL_INTEGER(lp_ldap_replication_sleep, &Globals.ldap_replication_sleep)
@@ -6156,6 +6172,11 @@ bool lp_add_home(const char *pszHomename, int iDefaultService,
 {
        int i;
 
+       if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
+                       pszHomedir[0] == '\0') {
+               return false;
+       }
+
        i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
 
        if (i < 0)
@@ -8127,7 +8148,7 @@ static void lp_add_auto_services(char *str)
 
                home = get_user_home_dir(talloc_tos(), p);
 
-               if (home && homes >= 0)
+               if (home && home[0] && homes >= 0)
                        lp_add_home(p, homes, p, home);
 
                TALLOC_FREE(home);

diff --git a/source3/passdb/passdb.c b/source3/passdb/passdb.c
index 0678181669d3e9259f2bc07650143359ed1f84bb..b2c3b948f1b6f1917f6d2c4fc07d0af32bb38c98 100644 (file)
--- a/source3/passdb/passdb.c
+++ b/source3/passdb/passdb.c
@@ -2257,7 +2257,8 @@ bool is_dc_trusted_domain_situation(const char *domain_name)
 *******************************************************************/
 
 bool get_trust_pw_clear(const char *domain, char **ret_pwd,
-                       const char **account_name, uint32 *channel)
+                       const char **account_name,
+                       enum netr_SchannelType *channel)
 {
        char *pwd;
        time_t last_set_time;
@@ -2329,7 +2330,8 @@ bool get_trust_pw_clear(const char *domain, char **ret_pwd,
 *******************************************************************/
 
 bool get_trust_pw_hash(const char *domain, uint8 ret_pwd[16],
-                      const char **account_name, uint32 *channel)
+                      const char **account_name,
+                      enum netr_SchannelType *channel)
 {
        char *pwd = NULL;
        time_t last_set_time;

diff --git a/source3/passdb/secrets.c b/source3/passdb/secrets.c
index 36f401bc92803f7b8fd061d08207ea539221e6ac..29e06623960c4ce6a0a77c19d9827363d74f0450 100644 (file)
--- a/source3/passdb/secrets.c
+++ b/source3/passdb/secrets.c
@@ -392,7 +392,7 @@ void *secrets_get_trust_account_lock(TALLOC_CTX *mem_ctx, const char *domain)
  Routine to get the default secure channel type for trust accounts
 ************************************************************************/
 
-uint32 get_default_sec_channel(void)
+enum netr_SchannelType get_default_sec_channel(void)
 {
        if (lp_server_role() == ROLE_DOMAIN_BDC ||
            lp_server_role() == ROLE_DOMAIN_PDC) {
@@ -412,7 +412,7 @@ uint32 get_default_sec_channel(void)
 bool secrets_fetch_trust_account_password_legacy(const char *domain,
                                                 uint8 ret_pwd[16],
                                                 time_t *pass_last_set_time,
-                                                uint32 *channel)
+                                                enum netr_SchannelType *channel)
 {
        struct machine_acct_pass *pass;
        size_t size = 0;
@@ -458,7 +458,7 @@ bool secrets_fetch_trust_account_password_legacy(const char *domain,
 
 bool secrets_fetch_trust_account_password(const char *domain, uint8 ret_pwd[16],
                                          time_t *pass_last_set_time,
-                                         uint32 *channel)
+                                         enum netr_SchannelType *channel)
 {
        char *plaintext;
 
@@ -793,7 +793,8 @@ bool secrets_delete_domain_sid(const char *domain)
 the password is assumed to be a null terminated ascii string
 ************************************************************************/
 
-bool secrets_store_machine_password(const char *pass, const char *domain, uint32 sec_channel)
+bool secrets_store_machine_password(const char *pass, const char *domain,
+                                   enum netr_SchannelType sec_channel)
 {
        bool ret;
        uint32 last_change_time;
@@ -819,7 +820,7 @@ bool secrets_store_machine_password(const char *pass, const char *domain, uint32
 
 char *secrets_fetch_machine_password(const char *domain,
                                     time_t *pass_last_set_time,
-                                    uint32 *channel)
+                                    enum netr_SchannelType *channel)
 {
        char *ret;
        ret = (char *)secrets_fetch(machine_password_keystr(domain), NULL);
@@ -890,6 +891,7 @@ bool fetch_ldap_pw(char **dn, char** pw)
        if (asprintf(&key, "%s/%s", SECRETS_LDAP_BIND_PW, *dn) < 0) {
                SAFE_FREE(*dn);
                DEBUG(0, ("fetch_ldap_pw: asprintf failed!\n"));
+               return false;
        }
 
        *pw=(char *)secrets_fetch(key, &size);

diff --git a/source3/passdb/util_unixsids.c b/source3/passdb/util_unixsids.c
index ad4e70256dddc23a6786413e89db4cd2fff9977b..ad51253058e9a619be4b64c11c3c9afbca3c5d0d 100644 (file)
--- a/source3/passdb/util_unixsids.c
+++ b/source3/passdb/util_unixsids.c
@@ -2,17 +2,17 @@
    Unix SMB/CIFS implementation.
    Translate unix-defined names to SIDs and vice versa
    Copyright (C) Volker Lendecke 2005
-      
+
    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/>.
 */
@@ -31,7 +31,7 @@ bool sid_check_is_in_unix_users(const DOM_SID *sid)
 
        sid_copy(&dom_sid, sid);
        sid_split_rid(&dom_sid, &rid);
-       
+
        return sid_check_is_unix_users(&dom_sid);
 }
 
@@ -80,7 +80,7 @@ bool sid_check_is_in_unix_groups(const DOM_SID *sid)
 
        sid_copy(&dom_sid, sid);
        sid_split_rid(&dom_sid, &rid);
-       
+
        return sid_check_is_unix_groups(&dom_sid);
 }
 

diff --git a/source3/printing/nt_printing.c b/source3/printing/nt_printing.c
index b75e30bb3e85d0ef7be5fd2a123f09148c470ca4..9995dfe4721beda2508217a881e65eba9799cd49 100644 (file)
--- a/source3/printing/nt_printing.c
+++ b/source3/printing/nt_printing.c
@@ -3033,14 +3033,8 @@ done:
 static void map_sz_into_ctr(struct regval_ctr *ctr, const char *val_name,
                            const char *sz)
 {
-       smb_ucs2_t conv_str[1024];
-       size_t str_size;
-
        regval_ctr_delvalue(ctr, val_name);
-       str_size = push_ucs2(NULL, conv_str, sz, sizeof(conv_str),
-                            STR_TERMINATE | STR_NOALIGN);
-       regval_ctr_addvalue(ctr, val_name, REG_SZ,
-                           (char *) conv_str, str_size);
+       regval_ctr_addvalue_sz(ctr, val_name, sz);
 }
 
 static void map_dword_into_ctr(struct regval_ctr *ctr, const char *val_name,
@@ -3063,26 +3057,13 @@ static void map_bool_into_ctr(struct regval_ctr *ctr, const char *val_name,
 static void map_single_multi_sz_into_ctr(struct regval_ctr *ctr, const char *val_name,
                                         const char *multi_sz)
 {
-       smb_ucs2_t *conv_strs = NULL;
-       size_t str_size;
-
-       /* a multi-sz has to have a null string terminator, i.e., the last
-          string must be followed by two nulls */
-       str_size = strlen(multi_sz) + 2;
-       conv_strs = SMB_CALLOC_ARRAY(smb_ucs2_t, str_size);
-       if (!conv_strs) {
-               return;
-       }
+       const char *a[2];
 
-       /* Change to byte units. */
-       str_size *= sizeof(smb_ucs2_t);
-       push_ucs2(NULL, conv_strs, multi_sz, str_size,
-                 STR_TERMINATE | STR_NOALIGN);
+       a[0] = multi_sz;
+       a[1] = NULL;
 
        regval_ctr_delvalue(ctr, val_name);
-       regval_ctr_addvalue(ctr, val_name, REG_MULTI_SZ,
-                           (char *) conv_strs, str_size);
-       SAFE_FREE(conv_strs);
+       regval_ctr_addvalue_multi_sz(ctr, val_name, a);
 }
 
 /****************************************************************************
@@ -3167,7 +3148,6 @@ static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2 *info2,
 {
        int i;
        struct regval_ctr *ctr=NULL;
-       UNISTR2 unistr_guid;
 
        /* find the DsSpooler key */
        if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
@@ -3179,15 +3159,8 @@ static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2 *info2,
        /* We used to store this as a REG_BINARY but that causes
           Vista to whine */
 
-       ZERO_STRUCT( unistr_guid );
-
-       init_unistr2( &unistr_guid, GUID_string(talloc_tos(), &guid),
-                     UNI_STR_TERMINATE );
-
-       regval_ctr_addvalue(ctr, "objectGUID", REG_SZ,
-                           (char *)unistr_guid.buffer,
-                           unistr_guid.uni_max_len*2);
-
+       regval_ctr_addvalue_sz(ctr, "objectGUID",
+                              GUID_string(talloc_tos(), &guid));
 }
 
 static WERROR nt_printer_publish_ads(ADS_STRUCT *ads,
@@ -3463,6 +3436,7 @@ bool is_printer_published(Printer_entry *print_hnd, int snum,
        WERROR win_rc;
        int i;
        bool ret = False;
+       DATA_BLOB blob;
 
        win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
 
@@ -3479,16 +3453,18 @@ bool is_printer_published(Printer_entry *print_hnd, int snum,
        /* fetching printer guids really ought to be a separate function. */
 
        if ( guid ) {
-               fstring guid_str;
+               char *guid_str;
 
                /* We used to store the guid as REG_BINARY, then swapped
                   to REG_SZ for Vista compatibility so check for both */
 
                switch ( regval_type(guid_val) ){
                case REG_SZ:
-                       rpcstr_pull( guid_str, regval_data_p(guid_val),
-                                    sizeof(guid_str)-1, -1, STR_TERMINATE );
+                       blob = data_blob_const(regval_data_p(guid_val),
+                                              regval_size(guid_val));
+                       pull_reg_sz(talloc_tos(), &blob, (const char **)&guid_str);
                        ret = NT_STATUS_IS_OK(GUID_from_string( guid_str, guid ));
+                       talloc_free(guid_str);
                        break;
                case REG_BINARY:
                        if ( regval_size(guid_val) != sizeof(struct GUID) ) {
@@ -3784,22 +3760,14 @@ static int unpack_values(NT_PRINTER_DATA *printer_data, const uint8 *buf, int bu
                     strequal( valuename, "objectGUID" ) )
                {
                        struct GUID guid;
-                       UNISTR2 unistr_guid;
-
-                       ZERO_STRUCT( unistr_guid );
 
                        /* convert the GUID to a UNICODE string */
 
                        memcpy( &guid, data_p, sizeof(struct GUID) );
 
-                       init_unistr2( &unistr_guid,
-                                     GUID_string(talloc_tos(), &guid),
-                                     UNI_STR_TERMINATE );
-
-                       regval_ctr_addvalue( printer_data->keys[key_index].values,
-                                            valuename, REG_SZ,
-                                            (const char *)unistr_guid.buffer,
-                                            unistr_guid.uni_str_len*2 );
+                       regval_ctr_addvalue_sz(printer_data->keys[key_index].values,
+                                              valuename,
+                                              GUID_string(talloc_tos(), &guid));
 
                } else {
                        /* add the value */

diff --git a/source3/registry/reg_backend_current_version.c b/source3/registry/reg_backend_current_version.c
index 1a3b2819a68a9c818282047050692db3a7f0e996..386c580965ddfc495ea63688070fc7500a7d32ba 100644 (file)
--- a/source3/registry/reg_backend_current_version.c
+++ b/source3/registry/reg_backend_current_version.c
@@ -37,8 +37,6 @@ static int current_version_fetch_values(const char *key, struct regval_ctr *valu
 {
        const char *sysroot_string = "c:\\Windows";
        fstring sysversion;
-       fstring value;
-       uint32 value_length;
        char *path = NULL;
        TALLOC_CTX *ctx = talloc_tos();
 
@@ -55,16 +53,12 @@ static int current_version_fetch_values(const char *key, struct regval_ctr *valu
                return regdb_ops.fetch_values(key, values);
        }
 
-       value_length = push_ucs2(value, value, sysroot_string, sizeof(value),
-                                STR_TERMINATE|STR_NOALIGN );
-       regval_ctr_addvalue(values, "SystemRoot", REG_SZ, value, value_length);
+       regval_ctr_addvalue_sz(values, "SystemRoot", sysroot_string);
 
        fstr_sprintf(sysversion, "%d.%d", lp_major_announce_version(),
                     lp_minor_announce_version());
-       value_length = push_ucs2(value, value, sysversion, sizeof(value),
-                                STR_TERMINATE|STR_NOALIGN);
-       regval_ctr_addvalue(values, "CurrentVersion", REG_SZ, value,
-                           value_length);
+
+       regval_ctr_addvalue_sz(values, "CurrentVersion", sysversion);
 
        return regval_ctr_numvals(values);
 }

diff --git a/source3/registry/reg_backend_db.c b/source3/registry/reg_backend_db.c
index dec43ae741a9f7160d83d07f82da5b84356abab3..2b6259c03ad330cff0154e391629f0acbfefaa7e 100644 (file)
--- a/source3/registry/reg_backend_db.c
+++ b/source3/registry/reg_backend_db.c
@@ -250,8 +250,6 @@ WERROR init_registry_key(const char *add_path)
 static void regdb_ctr_add_value(struct regval_ctr *ctr,
                                struct builtin_regkey_value *value)
 {
-       UNISTR2 data;
-
        switch(value->type) {
        case REG_DWORD:
                regval_ctr_addvalue(ctr, value->valuename, REG_DWORD,
@@ -260,10 +258,8 @@ static void regdb_ctr_add_value(struct regval_ctr *ctr,
                break;
 
        case REG_SZ:
-               init_unistr2(&data, value->data.string, UNI_STR_TERMINATE);
-               regval_ctr_addvalue(ctr, value->valuename, REG_SZ,
-                                   (char*)data.buffer,
-                                   data.uni_str_len*sizeof(uint16));
+               regval_ctr_addvalue_sz(ctr, value->valuename,
+                                      value->data.string);
                break;
 
        default:

diff --git a/source3/registry/reg_backend_printing.c b/source3/registry/reg_backend_printing.c
index 8c6f673ace342f0ff725ce3dd8bff8555c3bd68c..453e2b2d0cc729ca65edf33b1cda94f7cd69f1ee 100644 (file)
--- a/source3/registry/reg_backend_printing.c
+++ b/source3/registry/reg_backend_printing.c
@@ -386,7 +386,6 @@ static bool key_printers_store_keys( const char *key, struct regsubkey_ctr *subk
 static void fill_in_printer_values(NT_PRINTER_INFO_LEVEL_2 *info2, struct regval_ctr *values)
 {
        struct spoolss_DeviceMode *devmode;
-       UNISTR2         data;
        char            *p;
        uint32 printer_status = PRINTER_STATUS_OK;
        
@@ -406,35 +405,17 @@ static void fill_in_printer_values(NT_PRINTER_INFO_LEVEL_2 *info2, struct regval
                p = info2->printername;
        else
                p++;
-       init_unistr2( &data, p, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Name", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
 
-       init_unistr2( &data, info2->location, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Location", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, info2->comment, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Description", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, info2->parameters, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Parameters", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, info2->portname, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Port", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, info2->sharename, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Share Name", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, info2->drivername, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Printer Driver", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, info2->sepfile, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Separator File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, "WinPrint", UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Print Processor",  REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
-       init_unistr2( &data, "RAW", UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Datatype", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+       regval_ctr_addvalue_sz(values, "Name", p);
+       regval_ctr_addvalue_sz(values, "Location", info2->location);
+       regval_ctr_addvalue_sz(values, "Description", info2->comment);
+       regval_ctr_addvalue_sz(values, "Parameters", info2->parameters);
+       regval_ctr_addvalue_sz(values, "Port", info2->portname);
+       regval_ctr_addvalue_sz(values, "Share Name", info2->sharename);
+       regval_ctr_addvalue_sz(values, "Printer Driver", info2->drivername);
+       regval_ctr_addvalue_sz(values, "Separator File", info2->sepfile);
+       regval_ctr_addvalue_sz(values, "Print Processor", "WinPrint");
+       regval_ctr_addvalue_sz(values, "Datatype", "RAW");
 
        /* stream the device mode */
 
@@ -594,7 +575,16 @@ static int find_valuename_index( const char *valuename )
 /**********************************************************************
  *********************************************************************/
 
-static void convert_values_to_printer_info_2(NT_PRINTER_INFO_LEVEL_2 *printer2, struct regval_ctr *values)
+static void pull_reg_sz_fstring(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, fstring s)
+{
+       const char *str;
+       pull_reg_sz(mem_ctx, blob, &str);
+       fstrcpy(s, str);
+}
+
+static void convert_values_to_printer_info_2(TALLOC_CTX *mem_ctx,
+                                            NT_PRINTER_INFO_LEVEL_2 *printer2,
+                                            struct regval_ctr *values)
 {
        int num_values = regval_ctr_numvals( values );
        uint32 value_index;
@@ -602,8 +592,11 @@ static void convert_values_to_printer_info_2(NT_PRINTER_INFO_LEVEL_2 *printer2,
        int i;
        
        for ( i=0; i<num_values; i++ ) {
+               DATA_BLOB blob;
                val = regval_ctr_specific_value( values, i );
                value_index = find_valuename_index( regval_name( val ) );
+
+               blob = data_blob_const(regval_data_p(val), regval_size(val));
                
                switch( value_index ) {
                        case REG_IDX_ATTRIBUTES:
@@ -625,34 +618,34 @@ static void convert_values_to_printer_info_2(NT_PRINTER_INFO_LEVEL_2 *printer2,
                                printer2->untiltime = (uint32)(*regval_data_p(val));
                                break;
                        case REG_IDX_NAME:
-                               rpcstr_pull( printer2->printername, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->printername);
                                break;
                        case REG_IDX_LOCATION:
-                               rpcstr_pull( printer2->location, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->location);
                                break;
                        case REG_IDX_DESCRIPTION:
-                               rpcstr_pull( printer2->comment, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->comment);
                                break;
                        case REG_IDX_PARAMETERS:
-                               rpcstr_pull( printer2->parameters, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->parameters);
                                break;
                        case REG_IDX_PORT:
-                               rpcstr_pull( printer2->portname, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->portname);
                                break;
                        case REG_IDX_SHARENAME:
-                               rpcstr_pull( printer2->sharename, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->sharename);
                                break;
                        case REG_IDX_DRIVER:
-                               rpcstr_pull( printer2->drivername, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->drivername);
                                break;
                        case REG_IDX_SEP_FILE:
-                               rpcstr_pull( printer2->sepfile, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->sepfile);
                                break;
                        case REG_IDX_PRINTPROC:
-                               rpcstr_pull( printer2->printprocessor, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->printprocessor);
                                break;
                        case REG_IDX_DATATYPE:
-                               rpcstr_pull( printer2->datatype, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+                               pull_reg_sz_fstring(mem_ctx, &blob, printer2->datatype);
                                break;
                        case REG_IDX_DEVMODE:
                                break;
@@ -677,6 +670,7 @@ static bool key_printers_store_values(const char *key, struct regval_ctr *values
        char *printername, *keyname;
        NT_PRINTER_INFO_LEVEL   *printer = NULL;
        WERROR result;
+       TALLOC_CTX *mem_ctx = talloc_init("key_printers_store_values");
        
        printers_key = strip_printers_prefix( key );
        
@@ -697,7 +691,7 @@ static bool key_printers_store_values(const char *key, struct regval_ctr *values
        /* deal with setting values directly under the printername */
 
        if ( !keyname ) {
-               convert_values_to_printer_info_2( printer->info_2, values );
+               convert_values_to_printer_info_2(mem_ctx, printer->info_2, values );
        }
        else {
                int num_values = regval_ctr_numvals( values );
@@ -718,6 +712,7 @@ static bool key_printers_store_values(const char *key, struct regval_ctr *values
                                DEBUG(0,("key_printers_store_values: failed to set printer data [%s]!\n",
                                        keyname));
                                free_a_printer( &printer, 2 );
+                               talloc_destroy(mem_ctx);
                                return False;
                        }
                }
@@ -726,6 +721,7 @@ static bool key_printers_store_values(const char *key, struct regval_ctr *values
        result = mod_a_printer( printer, 2 );
 
        free_a_printer( &printer, 2 );
+       talloc_destroy(mem_ctx);
 
        return W_ERROR_IS_OK(result);
 }
@@ -894,31 +890,21 @@ static void fill_in_driver_values(NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3, struct
        int buffer_size = 0;
        int i, length;
        const char *filename;
-       UNISTR2 data;
+       DATA_BLOB data;
 
        filename = dos_basename( info3->driverpath );
-       init_unistr2( &data, filename, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Driver", REG_SZ, (char*)data.buffer,
-               data.uni_str_len*sizeof(uint16) );
+       regval_ctr_addvalue_sz(values, "Driver", filename);
 
        filename = dos_basename( info3->configfile );
-       init_unistr2( &data, filename, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Configuration File", REG_SZ, (char*)data.buffer, 
-               data.uni_str_len*sizeof(uint16) );
+       regval_ctr_addvalue_sz(values, "Configuration File", filename);
 
        filename = dos_basename( info3->datafile );
-       init_unistr2( &data, filename, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Data File", REG_SZ, (char*)data.buffer,
-               data.uni_str_len*sizeof(uint16) );
+       regval_ctr_addvalue_sz(values, "Data File", filename);
 
        filename = dos_basename( info3->helpfile );
-       init_unistr2( &data, filename, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Help File", REG_SZ, (char*)data.buffer,
-               data.uni_str_len*sizeof(uint16) );
+       regval_ctr_addvalue_sz(values, "Help File", filename);
 
-       init_unistr2( &data, info3->defaultdatatype, UNI_STR_TERMINATE);
-       regval_ctr_addvalue( values, "Data Type", REG_SZ, (char*)data.buffer,
-               data.uni_str_len*sizeof(uint16) );
+       regval_ctr_addvalue_sz(values, "Data Type", info3->defaultdatatype);
 
        regval_ctr_addvalue( values, "Version", REG_DWORD, (char*)&info3->cversion, 
                sizeof(info3->cversion) );
@@ -940,8 +926,8 @@ static void fill_in_driver_values(NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3, struct
                                break;
                        }
 
-                       init_unistr2( &data, filename, UNI_STR_TERMINATE);
-                       memcpy( buffer+buffer_size, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+                       push_reg_sz(talloc_tos(), &data, filename);
+                       memcpy( buffer+buffer_size, (char*)data.data, data.length);
 
                        buffer_size += (length + 1)*sizeof(uint16);
                }

diff --git a/source3/registry/reg_backend_prod_options.c b/source3/registry/reg_backend_prod_options.c
index cdc1f37e72829b370ac7fda0ee07e856700e968c..786bc99eb1a240330e11badfed8bb29c72a702ad 100644 (file)
--- a/source3/registry/reg_backend_prod_options.c
+++ b/source3/registry/reg_backend_prod_options.c
@@ -34,8 +34,6 @@ extern struct registry_ops regdb_ops;
 static int prod_options_fetch_values(const char *key, struct regval_ctr *regvals)
 {
        const char *value_ascii = "";
-       fstring value;
-       int value_length;
 
        switch (lp_server_role()) {
                case ROLE_DOMAIN_PDC:
@@ -50,10 +48,7 @@ static int prod_options_fetch_values(const char *key, struct regval_ctr *regvals
                        break;
        }
 
-       value_length = push_ucs2(value, value, value_ascii, sizeof(value),
-                                STR_TERMINATE|STR_NOALIGN );
-       regval_ctr_addvalue(regvals, "ProductType", REG_SZ, value,
-                           value_length);
+       regval_ctr_addvalue_sz(regvals, "ProductType", value_ascii);
 
        return regval_ctr_numvals( regvals );
 }

diff --git a/source3/registry/reg_backend_tcpip_params.c b/source3/registry/reg_backend_tcpip_params.c
index 30f7f719382b725ee63d2a38c31c4c99c766ec7c..fbad0436b61e030b43c816a9f1a53a1669ea967f 100644 (file)
--- a/source3/registry/reg_backend_tcpip_params.c
+++ b/source3/registry/reg_backend_tcpip_params.c
@@ -33,24 +33,9 @@ extern struct registry_ops regdb_ops;
 
 static int tcpip_params_fetch_values(const char *key, struct regval_ctr *regvals)
 {
-       fstring value;
-       int value_length;
-       char *hname;
-       char *mydomainname = NULL;
+       regval_ctr_addvalue_sz(regvals, "Hostname", myhostname());
 
-       hname = myhostname();
-       value_length = push_ucs2(value, value, hname, sizeof(value),
-                                STR_TERMINATE|STR_NOALIGN);
-       regval_ctr_addvalue(regvals, "Hostname",REG_SZ, value, value_length);
-
-       mydomainname = get_mydnsdomname(talloc_tos());
-       if (!mydomainname) {
-               return -1;
-       }
-
-       value_length = push_ucs2(value, value, mydomainname, sizeof(value),
-                                STR_TERMINATE|STR_NOALIGN);
-       regval_ctr_addvalue(regvals, "Domain", REG_SZ, value, value_length);
+       regval_ctr_addvalue_sz(regvals, "Domain", get_mydnsdomname(talloc_tos()));
 
        return regval_ctr_numvals(regvals);
 }

diff --git a/source3/registry/reg_eventlog.c b/source3/registry/reg_eventlog.c
index 45ade5210291ba6df17c70c8dc540312cba0f686..722cd58f696a763725e3764b8ca4f563d6a1008b 100644 (file)
--- a/source3/registry/reg_eventlog.c
+++ b/source3/registry/reg_eventlog.c
@@ -40,7 +40,7 @@ bool eventlog_init_keys(void)
        uint32 uiMaxSize;
        uint32 uiRetention;
        uint32 uiCategoryCount;
-       UNISTR2 data;
+       DATA_BLOB data;
        TALLOC_CTX *ctx = talloc_tos();
        WERROR werr;
 
@@ -114,18 +114,13 @@ bool eventlog_init_keys(void)
                        regval_ctr_addvalue(values, "Retention", REG_DWORD,
                                             (char *)&uiRetention,
                                             sizeof(uint32));
-                       init_unistr2(&data, *elogs, UNI_STR_TERMINATE);
 
-                       regval_ctr_addvalue(values, "PrimaryModule", REG_SZ,
-                                            (char *)data.buffer,
-                                            data.uni_str_len *
-                                            sizeof(uint16));
-                       init_unistr2(&data, *elogs, UNI_STR_TERMINATE);
+                       regval_ctr_addvalue_sz(values, "PrimaryModule", *elogs);
+                       push_reg_sz(talloc_tos(), &data, *elogs);
 
                        regval_ctr_addvalue(values, "Sources", REG_MULTI_SZ,
-                                            (char *)data.buffer,
-                                            data.uni_str_len *
-                                            sizeof(uint16));
+                                            (char *)data.data,
+                                            data.length);
 
                        evtfilepath = talloc_asprintf(ctx,
                                        "%%SystemRoot%%\\system32\\config\\%s.tdb",
@@ -133,9 +128,9 @@ bool eventlog_init_keys(void)
                        if (!evtfilepath) {
                                TALLOC_FREE(values);
                        }
-                       init_unistr2(&data, evtfilepath, UNI_STR_TERMINATE);
-                       regval_ctr_addvalue(values, "File", REG_EXPAND_SZ, (char *)data.buffer,
-                                            data.uni_str_len * sizeof(uint16));
+                       push_reg_sz(talloc_tos(), &data, evtfilepath);
+                       regval_ctr_addvalue(values, "File", REG_EXPAND_SZ, (char *)data.data,
+                                            data.length);
                        regdb_store_values(evtlogpath, values);
 
                }
@@ -166,15 +161,13 @@ bool eventlog_init_keys(void)
                                             REG_DWORD,
                                             ( char * ) &uiCategoryCount,
                                             sizeof( uint32 ) );
-                       init_unistr2( &data,
-                                     "%SystemRoot%\\system32\\eventlog.dll",
-                                     UNI_STR_TERMINATE );
+                       push_reg_sz(talloc_tos(), &data,
+                                     "%SystemRoot%\\system32\\eventlog.dll");
 
                        regval_ctr_addvalue( values, "CategoryMessageFile",
                                             REG_EXPAND_SZ,
-                                            ( char * ) data.buffer,
-                                            data.uni_str_len *
-                                            sizeof( uint16 ) );
+                                            ( char * ) data.data,
+                                            data.length);
                        regdb_store_values( evtlogpath, values );
                }
                TALLOC_FREE(values);
@@ -198,19 +191,18 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
           need to add KEY of source to KEY_EVENTLOG/<eventlog>/<source> */
 
        const char **elogs = lp_eventlog_list(  );
-       char **wrklist, **wp;
+       const char **wrklist, **wp;
        char *evtlogpath = NULL;
        struct regsubkey_ctr *subkeys;
        struct regval_ctr *values;
        struct regval_blob *rval;
-       UNISTR2 data;
-       uint16 *msz_wp;
-       int mbytes, ii;
+       int ii = 0;
        bool already_in;
        int i;
-       int numsources;
+       int numsources = 0;
        TALLOC_CTX *ctx = talloc_tos();
        WERROR werr;
+       DATA_BLOB blob;
 
        if (!elogs) {
                return False;
@@ -264,15 +256,21 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
        already_in = False;
        wrklist = NULL;
        dump_data( 1, rval->data_p, rval->size );
-       if ( ( numsources =
-              regval_convert_multi_sz( ( uint16 * ) rval->data_p, rval->size,
-                                       &wrklist ) ) > 0 ) {
 
-               ii = numsources;
+       blob = data_blob_const(rval->data_p, rval->size);
+       if (!pull_reg_multi_sz(talloc_tos(), &blob, &wrklist)) {
+               return false;
+       }
+
+       for (ii=0; wrklist[ii]; ii++) {
+               numsources++;
+       }
+
+       if (numsources > 0) {
                /* see if it's in there already */
                wp = wrklist;
 
-               while ( ii && wp && *wp ) {
+               while (wp && *wp ) {
                        if ( strequal( *wp, sourcename ) ) {
                                DEBUG( 5,
                                       ( "Source name [%s] already in list for [%s] \n",
@@ -281,13 +279,8 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
                                break;
                        }
                        wp++;
-                       ii--;
                }
        } else {
-               if ( numsources < 0 ) {
-                       DEBUG( 3, ( "problem in getting the sources\n" ) );
-                       return False;
-               }
                DEBUG( 3,
                       ( "Nothing in the sources list, this might be a problem\n" ) );
        }
@@ -296,7 +289,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
 
        if ( !already_in ) {
                /* make a new list with an additional entry; copy values, add another */
-               wp = TALLOC_ARRAY(ctx, char *, numsources + 2 );
+               wp = TALLOC_ARRAY(ctx, const char *, numsources + 2 );
 
                if ( !wp ) {
                        DEBUG( 0, ( "talloc() failed \n" ) );
@@ -305,12 +298,14 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
                memcpy( wp, wrklist, sizeof( char * ) * numsources );
                *( wp + numsources ) = ( char * ) sourcename;
                *( wp + numsources + 1 ) = NULL;
-               mbytes = regval_build_multi_sz( wp, &msz_wp );
-               dump_data( 1, ( uint8 * ) msz_wp, mbytes );
+               if (!push_reg_multi_sz(ctx, &blob, wp)) {
+                       return false;
+               }
+               dump_data( 1, blob.data, blob.length);
                regval_ctr_addvalue( values, "Sources", REG_MULTI_SZ,
-                                    ( char * ) msz_wp, mbytes );
+                                    ( char * ) blob.data, blob.length);
                regdb_store_values( evtlogpath, values );
-               TALLOC_FREE(msz_wp);
+               data_blob_free(&blob);
        } else {
                DEBUG( 3,
                       ( "Source name [%s] found in existing list of sources\n",
@@ -373,11 +368,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
 
        regdb_fetch_values( evtlogpath, values );
 
-       init_unistr2( &data, messagefile, UNI_STR_TERMINATE );
-
-       regval_ctr_addvalue( values, "EventMessageFile", REG_SZ,
-                            ( char * ) data.buffer,
-                            data.uni_str_len * sizeof( uint16 ) );
+       regval_ctr_addvalue_sz(values, "EventMessageFile", messagefile);
        regdb_store_values( evtlogpath, values );
 
        TALLOC_FREE(values);

diff --git a/source3/registry/reg_objects.c b/source3/registry/reg_objects.c
index 0c0455aadadb21bca029c37412d3daea4f336c01..b4b8ff26307d79124a6bc0e55af3630bf672f27a 100644 (file)
--- a/source3/registry/reg_objects.c
+++ b/source3/registry/reg_objects.c
@@ -489,6 +489,40 @@ int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
        return ctr->num_values;
 }
 
+/***********************************************************************
+ Add a new registry SZ value to the array
+ **********************************************************************/
+
+int regval_ctr_addvalue_sz(struct regval_ctr *ctr, const char *name, const char *data)
+{
+       DATA_BLOB blob;
+
+       if (!push_reg_sz(ctr, &blob, data)) {
+               return -1;
+       }
+
+       return regval_ctr_addvalue(ctr, name, REG_SZ,
+                                  (const char *)blob.data,
+                                  blob.length);
+}
+
+/***********************************************************************
+ Add a new registry MULTI_SZ value to the array
+ **********************************************************************/
+
+int regval_ctr_addvalue_multi_sz(struct regval_ctr *ctr, const char *name, const char **data)
+{
+       DATA_BLOB blob;
+
+       if (!push_reg_multi_sz(ctr, &blob, data)) {
+               return -1;
+       }
+
+       return regval_ctr_addvalue(ctr, name, REG_MULTI_SZ,
+                                  (const char *)blob.data,
+                                  blob.length);
+}
+
 /***********************************************************************
  Add a new registry value to the array
  **********************************************************************/
@@ -568,11 +602,12 @@ uint32 regval_dword(struct regval_blob *val)
  return the data_p as a character string
  **********************************************************************/
 
-char *regval_sz(struct regval_blob *val)
+const char *regval_sz(struct regval_blob *val)
 {
-       char *data = NULL;
+       const char *data = NULL;
+       DATA_BLOB blob = data_blob_const(regval_data_p(val), regval_size(val));
+
+       pull_reg_sz(talloc_tos(), &blob, &data);
 
-       rpcstr_pull_talloc(talloc_tos(), &data,
-                       regval_data_p(val), regval_size(val),0);
        return data;
 }

diff --git a/source3/registry/reg_perfcount.c b/source3/registry/reg_perfcount.c
index 14716b2f532cb52154ccca9ddd0595e0bf13337a..1991af10ca52e8fae6d1f0109d60b3bd0b0a6a38 100644 (file)
--- a/source3/registry/reg_perfcount.c
+++ b/source3/registry/reg_perfcount.c
@@ -30,7 +30,7 @@
 #define NAMES_DB       "names.tdb"
 #define DATA_DB                "data.tdb"
 
-PERF_OBJECT_TYPE *_reg_perfcount_find_obj(PERF_DATA_BLOCK *block, int objind);
+struct PERF_OBJECT_TYPE *_reg_perfcount_find_obj(struct PERF_DATA_BLOCK *block, int objind);
 
 /*********************************************************************
 *********************************************************************/
@@ -161,7 +161,7 @@ static uint32 _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb,
        char temp[256];
        char *buf1 = *retbuf;
        uint32 working_size = 0;
-       UNISTR2 name_index, name;
+       DATA_BLOB name_index, name;
 
        memset(temp, 0, sizeof(temp));
        snprintf(temp, sizeof(temp), "%d", keyval);
@@ -182,8 +182,8 @@ static uint32 _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb,
                buffer_size = 0;
                return buffer_size;
        }
-       init_unistr2(&name_index, (const char *)kbuf.dptr, UNI_STR_TERMINATE);
-       memcpy(buf1+buffer_size, (char *)name_index.buffer, working_size);
+       push_reg_sz(talloc_tos(), &name_index, (const char *)kbuf.dptr);
+       memcpy(buf1+buffer_size, (char *)name_index.data, working_size);
        buffer_size += working_size;
        /* Now encode the actual name */
        working_size = (dbuf.dsize + 1)*sizeof(uint16);
@@ -195,8 +195,8 @@ static uint32 _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb,
        memset(temp, 0, sizeof(temp));
        memcpy(temp, dbuf.dptr, dbuf.dsize);
        SAFE_FREE(dbuf.dptr);
-       init_unistr2(&name, temp, UNI_STR_TERMINATE);
-       memcpy(buf1+buffer_size, (char *)name.buffer, working_size);
+       push_reg_sz(talloc_tos(), &name, temp);
+       memcpy(buf1+buffer_size, (char *)name.data, working_size);
        buffer_size += working_size;
 
        *retbuf = buf1;
@@ -365,24 +365,29 @@ static uint32 _reg_perfcount_get_numinst(int objInd, TDB_CONTEXT *names)
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_add_object(PERF_DATA_BLOCK *block,
-                                     prs_struct *ps,
+static bool _reg_perfcount_add_instance(struct PERF_OBJECT_TYPE *obj,
+                                       TALLOC_CTX *mem_ctx,
+                                       int instInd,
+                                       TDB_CONTEXT *names);
+
+static bool _reg_perfcount_add_object(struct PERF_DATA_BLOCK *block,
+                                     TALLOC_CTX *mem_ctx,
                                      int num,
                                      TDB_DATA data,
                                      TDB_CONTEXT *names)
 {
        int i;
        bool success = True;
-       PERF_OBJECT_TYPE *obj;
+       struct PERF_OBJECT_TYPE *obj;
 
-       block->objects = (PERF_OBJECT_TYPE *)TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+       block->objects = (struct PERF_OBJECT_TYPE *)TALLOC_REALLOC_ARRAY(mem_ctx,
                                                                  block->objects,
-                                                                 PERF_OBJECT_TYPE,
+                                                                 struct PERF_OBJECT_TYPE,
                                                                  block->NumObjectTypes+1);
        if(block->objects == NULL)
                return False;
        obj = &(block->objects[block->NumObjectTypes]);
-       memset((void *)&(block->objects[block->NumObjectTypes]), 0, sizeof(PERF_OBJECT_TYPE));
+       memset((void *)&(block->objects[block->NumObjectTypes]), 0, sizeof(struct PERF_OBJECT_TYPE));
        block->objects[block->NumObjectTypes].ObjectNameTitleIndex = num;
        block->objects[block->NumObjectTypes].ObjectNameTitlePointer = 0;
        block->objects[block->NumObjectTypes].ObjectHelpTitleIndex = num+1;
@@ -398,7 +403,7 @@ static bool _reg_perfcount_add_object(PERF_DATA_BLOCK *block,
        block->NumObjectTypes+=1;
 
        for(i = 0; i < (int)obj->NumInstances; i++) {
-               success = _reg_perfcount_add_instance(obj, ps, i, names);
+               success = _reg_perfcount_add_instance(obj, mem_ctx, i, names);
        }
 
        return success;
@@ -407,7 +412,7 @@ static bool _reg_perfcount_add_object(PERF_DATA_BLOCK *block,
 /*********************************************************************
 *********************************************************************/
 
-bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data)
+static bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data)
 {
        TDB_CONTEXT *counters;
        const char *fname = counters_directory( DATA_DB );
@@ -469,10 +474,10 @@ static uint32 _reg_perfcount_compute_scale(int64_t data)
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_get_counter_info(PERF_DATA_BLOCK *block,
-                                           prs_struct *ps,
+static bool _reg_perfcount_get_counter_info(struct PERF_DATA_BLOCK *block,
+                                           TALLOC_CTX *mem_ctx,
                                            int CounterIndex,
-                                           PERF_OBJECT_TYPE *obj,
+                                           struct PERF_OBJECT_TYPE *obj,
                                            TDB_CONTEXT *names)
 {
        TDB_DATA key, data;
@@ -546,7 +551,7 @@ static bool _reg_perfcount_get_counter_info(PERF_DATA_BLOCK *block,
        SAFE_FREE(data.dptr);
 
        obj->counter_data.ByteLength += dsize + padding;
-       obj->counter_data.data = TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+       obj->counter_data.data = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                      obj->counter_data.data,
                                                      uint8,
                                                      obj->counter_data.ByteLength - sizeof(uint32));
@@ -578,11 +583,11 @@ static bool _reg_perfcount_get_counter_info(PERF_DATA_BLOCK *block,
 /*********************************************************************
 *********************************************************************/
 
-PERF_OBJECT_TYPE *_reg_perfcount_find_obj(PERF_DATA_BLOCK *block, int objind)
+struct PERF_OBJECT_TYPE *_reg_perfcount_find_obj(struct PERF_DATA_BLOCK *block, int objind)
 {
        int i;
 
-       PERF_OBJECT_TYPE *obj = NULL;
+       struct PERF_OBJECT_TYPE *obj = NULL;
 
        for(i = 0; i < block->NumObjectTypes; i++)
        {
@@ -598,15 +603,15 @@ PERF_OBJECT_TYPE *_reg_perfcount_find_obj(PERF_DATA_BLOCK *block, int objind)
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_add_counter(PERF_DATA_BLOCK *block,
-                                      prs_struct *ps,
+static bool _reg_perfcount_add_counter(struct PERF_DATA_BLOCK *block,
+                                      TALLOC_CTX *mem_ctx,
                                       int num,
                                       TDB_DATA data,
                                       TDB_CONTEXT *names)
 {
        char *begin, *end, *start, *stop;
        int parent;
-       PERF_OBJECT_TYPE *obj;
+       struct PERF_OBJECT_TYPE *obj;
        bool success = True;
        char buf[PERFCOUNT_MAX_LEN];
 
@@ -634,18 +639,18 @@ static bool _reg_perfcount_add_counter(PERF_DATA_BLOCK *block,
                                  parent, num));
                        return False;
                }
-               obj->counters = (PERF_COUNTER_DEFINITION *)TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+               obj->counters = (struct PERF_COUNTER_DEFINITION *)TALLOC_REALLOC_ARRAY(mem_ctx,
                                                                                obj->counters,
-                                                                               PERF_COUNTER_DEFINITION,
+                                                                               struct PERF_COUNTER_DEFINITION,
                                                                                obj->NumCounters+1);
                if(obj->counters == NULL)
                        return False;
-               memset((void *)&(obj->counters[obj->NumCounters]), 0, sizeof(PERF_COUNTER_DEFINITION));
+               memset((void *)&(obj->counters[obj->NumCounters]), 0, sizeof(struct PERF_COUNTER_DEFINITION));
                obj->counters[obj->NumCounters].CounterNameTitleIndex=num;
                obj->counters[obj->NumCounters].CounterHelpTitleIndex=num+1;
                obj->counters[obj->NumCounters].DetailLevel = PERF_DETAIL_NOVICE;
-               obj->counters[obj->NumCounters].ByteLength = sizeof(PERF_COUNTER_DEFINITION);
-               success = _reg_perfcount_get_counter_info(block, ps, num, obj, names);
+               obj->counters[obj->NumCounters].ByteLength = sizeof(struct PERF_COUNTER_DEFINITION);
+               success = _reg_perfcount_get_counter_info(block, mem_ctx, num, obj, names);
                obj->NumCounters += 1;
                start = stop + 1;
        }
@@ -660,11 +665,11 @@ static bool _reg_perfcount_add_counter(PERF_DATA_BLOCK *block,
 /*********************************************************************
 *********************************************************************/
 
-bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst,
-                                     prs_struct *ps,
-                                     int instId,
-                                     PERF_OBJECT_TYPE *obj,
-                                     TDB_CONTEXT *names)
+static bool _reg_perfcount_get_instance_info(struct PERF_INSTANCE_DEFINITION *inst,
+                                            TALLOC_CTX *mem_ctx,
+                                            int instId,
+                                            struct PERF_OBJECT_TYPE *obj,
+                                            TDB_CONTEXT *names)
 {
        TDB_DATA key, data;
        char buf[PERFCOUNT_MAX_LEN], temp[PERFCOUNT_MAX_LEN];
@@ -686,7 +691,7 @@ bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst,
                return False;
        }
        inst->counter_data.ByteLength = data.dsize + sizeof(inst->counter_data.ByteLength);
-       inst->counter_data.data = TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+       inst->counter_data.data = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                       inst->counter_data.data,
                                                       uint8,
                                                       data.dsize);
@@ -713,12 +718,12 @@ bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst,
                memset(buf, 0, PERFCOUNT_MAX_LEN);
                memcpy(buf, data.dptr, MIN(PERFCOUNT_MAX_LEN-1,data.dsize));
                buf[PERFCOUNT_MAX_LEN-1] = '\0';
-               inst->NameLength = rpcstr_push_talloc(ps->mem_ctx, &name, buf);
+               inst->NameLength = rpcstr_push_talloc(mem_ctx, &name, buf);
                if (inst->NameLength == (uint32_t)-1 || !name) {
                        SAFE_FREE(data.dptr);
                        return False;
                }
-               inst->data = TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+               inst->data = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                  inst->data,
                                                  uint8,
                                                  inst->NameLength);
@@ -740,7 +745,7 @@ bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst,
        if((pad = (inst->ByteLength % 8)))
        {
                pad = 8 - pad;
-               inst->data = TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+               inst->data = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                  inst->data,
                                                  uint8,
                                                  inst->NameLength + pad);
@@ -754,32 +759,32 @@ bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst,
 /*********************************************************************
 *********************************************************************/
 
-bool _reg_perfcount_add_instance(PERF_OBJECT_TYPE *obj,
-                                prs_struct *ps,
-                                int instInd,
-                                TDB_CONTEXT *names)
+static bool _reg_perfcount_add_instance(struct PERF_OBJECT_TYPE *obj,
+                                       TALLOC_CTX *mem_ctx,
+                                       int instInd,
+                                       TDB_CONTEXT *names)
 {
-       PERF_INSTANCE_DEFINITION *inst;
+       struct PERF_INSTANCE_DEFINITION *inst;
 
        if(obj->instances == NULL) {
-               obj->instances = TALLOC_REALLOC_ARRAY(ps->mem_ctx, 
+               obj->instances = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                      obj->instances,
-                                                     PERF_INSTANCE_DEFINITION,
+                                                     struct PERF_INSTANCE_DEFINITION,
                                                      obj->NumInstances);
        }
        if(obj->instances == NULL)
                return False;
 
-       memset(&(obj->instances[instInd]), 0, sizeof(PERF_INSTANCE_DEFINITION));
+       memset(&(obj->instances[instInd]), 0, sizeof(struct PERF_INSTANCE_DEFINITION));
        inst = &(obj->instances[instInd]);
-       return _reg_perfcount_get_instance_info(inst, ps, instInd, obj, names);
+       return _reg_perfcount_get_instance_info(inst, mem_ctx, instInd, obj, names);
 }
 
 /*********************************************************************
 *********************************************************************/
 
-static int _reg_perfcount_assemble_global(PERF_DATA_BLOCK *block,
-                                         prs_struct *ps,
+static int _reg_perfcount_assemble_global(struct PERF_DATA_BLOCK *block,
+                                         TALLOC_CTX *mem_ctx,
                                          int base_index,
                                          TDB_CONTEXT *names)
 {
@@ -796,9 +801,9 @@ static int _reg_perfcount_assemble_global(PERF_DATA_BLOCK *block,
                if(data.dptr != NULL)
                {
                        if(_reg_perfcount_isparent(data))
-                               success = _reg_perfcount_add_object(block, ps, j, data, names);
+                               success = _reg_perfcount_add_object(block, mem_ctx, j, data, names);
                        else if(_reg_perfcount_ischild(data))
-                               success = _reg_perfcount_add_counter(block, ps, j, data, names);
+                               success = _reg_perfcount_add_counter(block, mem_ctx, j, data, names);
                        else
                        {
                                DEBUG(3, ("Bogus relationship [%s] for counter [%d].\n", data.dptr, j));
@@ -849,7 +854,7 @@ static bool _reg_perfcount_get_64(uint64_t *retval,
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_init_data_block_perf(PERF_DATA_BLOCK *block,
+static bool _reg_perfcount_init_data_block_perf(struct PERF_DATA_BLOCK *block,
                                                TDB_CONTEXT *names)
 {
        uint64_t PerfFreq, PerfTime, PerfTime100nSec;
@@ -893,16 +898,34 @@ static bool _reg_perfcount_init_data_block_perf(PERF_DATA_BLOCK *block,
        return True;
 }
 
+/*******************************************************************
+********************************************************************/
+
+static bool make_systemtime(struct SYSTEMTIME *systime, struct tm *unixtime)
+{
+       systime->year=unixtime->tm_year+1900;
+       systime->month=unixtime->tm_mon+1;
+       systime->dayofweek=unixtime->tm_wday;
+       systime->day=unixtime->tm_mday;
+       systime->hour=unixtime->tm_hour;
+       systime->minute=unixtime->tm_min;
+       systime->second=unixtime->tm_sec;
+       systime->milliseconds=0;
+
+       return True;
+}
+
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_init_data_block(PERF_DATA_BLOCK *block,
-                                          prs_struct *ps, TDB_CONTEXT *names)
+static bool _reg_perfcount_init_data_block(struct PERF_DATA_BLOCK *block,
+                                          TALLOC_CTX *mem_ctx, TDB_CONTEXT *names,
+                                          bool bigendian_data)
 {
        smb_ucs2_t *temp = NULL;
        time_t tm;
 
-       if (rpcstr_push_talloc(ps->mem_ctx, &temp, "PERF")==(size_t)-1) {
+       if (rpcstr_push_talloc(mem_ctx, &temp, "PERF")==(size_t)-1) {
                return false;
        }
        if (!temp) {
@@ -910,7 +933,7 @@ static bool _reg_perfcount_init_data_block(PERF_DATA_BLOCK *block,
        }
        memcpy(block->Signature, temp, strlen_w(temp) *2);
 
-       if(ps->bigendian_data == RPC_BIG_ENDIAN)
+       if(bigendian_data)
                block->LittleEndian = 0;
        else
                block->LittleEndian = 1;
@@ -926,12 +949,12 @@ static bool _reg_perfcount_init_data_block(PERF_DATA_BLOCK *block,
        memset(temp, 0, sizeof(temp));
        rpcstr_push((void *)temp, global_myname(), sizeof(temp), STR_TERMINATE);
        block->SystemNameLength = (strlen_w(temp) * 2) + 2;
-       block->data = TALLOC_ZERO_ARRAY(ps->mem_ctx, uint8, block->SystemNameLength + (8 - (block->SystemNameLength % 8)));
+       block->data = TALLOC_ZERO_ARRAY(mem_ctx, uint8, block->SystemNameLength + (8 - (block->SystemNameLength % 8)));
        if (block->data == NULL) {
                return False;
        }
        memcpy(block->data, temp, block->SystemNameLength);
-       block->SystemNameOffset = sizeof(PERF_DATA_BLOCK) - sizeof(block->objects) - sizeof(block->data); 
+       block->SystemNameOffset = sizeof(struct PERF_DATA_BLOCK) - sizeof(block->objects) - sizeof(block->data);
        block->HeaderLength = block->SystemNameOffset + block->SystemNameLength;
        /* Make sure to adjust for 64-bit alignment for when we finish writing the system name,
           so that the PERF_OBJECT_TYPE struct comes out 64-bit aligned */
@@ -943,13 +966,13 @@ static bool _reg_perfcount_init_data_block(PERF_DATA_BLOCK *block,
 /*********************************************************************
 *********************************************************************/
 
-static uint32 _reg_perfcount_perf_data_block_fixup(PERF_DATA_BLOCK *block, prs_struct *ps)
+static uint32 _reg_perfcount_perf_data_block_fixup(struct PERF_DATA_BLOCK *block, TALLOC_CTX *mem_ctx)
 {
        int obj, cnt, inst, pad, i;
-       PERF_OBJECT_TYPE *object;
-       PERF_INSTANCE_DEFINITION *instance;
-       PERF_COUNTER_DEFINITION *counter;
-       PERF_COUNTER_BLOCK *counter_data;
+       struct PERF_OBJECT_TYPE *object;
+       struct PERF_INSTANCE_DEFINITION *instance;
+       struct PERF_COUNTER_DEFINITION *counter;
+       struct PERF_COUNTER_BLOCK *counter_data;
        char *temp = NULL, *src_addr, *dst_addr;
 
        block->TotalByteLength = 0;
@@ -974,7 +997,7 @@ static uint32 _reg_perfcount_perf_data_block_fixup(PERF_DATA_BLOCK *block, prs_s
                                counter_data = &(instance->counter_data);
                                counter = &(object[obj].counters[object[obj].NumCounters - 1]);
                                counter_data->ByteLength = counter->CounterOffset + counter->CounterSize + sizeof(counter_data->ByteLength);
-                               temp = TALLOC_REALLOC_ARRAY(ps->mem_ctx, 
+                               temp = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                            temp, 
                                                            char, 
                                                            counter_data->ByteLength- sizeof(counter_data->ByteLength));
@@ -995,7 +1018,7 @@ static uint32 _reg_perfcount_perf_data_block_fixup(PERF_DATA_BLOCK *block, prs_s
                                {
                                        pad = 8 - pad;
                                }
-                               counter_data->data = TALLOC_REALLOC_ARRAY(ps->mem_ctx,
+                               counter_data->data = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                                         counter_data->data,
                                                                         uint8,
                                                                         counter_data->ByteLength - sizeof(counter_data->ByteLength) + pad);
@@ -1015,7 +1038,7 @@ static uint32 _reg_perfcount_perf_data_block_fixup(PERF_DATA_BLOCK *block, prs_s
                        if((pad = (object[obj].counter_data.ByteLength % 8)))
                        {
                                pad = 8 - pad;
-                               object[obj].counter_data.data = TALLOC_REALLOC_ARRAY(ps->mem_ctx, 
+                               object[obj].counter_data.data = TALLOC_REALLOC_ARRAY(mem_ctx,
                                                                                     object[obj].counter_data.data,
                                                                                     uint8, 
                                                                                     object[obj].counter_data.ByteLength + pad);
@@ -1024,7 +1047,7 @@ static uint32 _reg_perfcount_perf_data_block_fixup(PERF_DATA_BLOCK *block, prs_s
                        }
                        object[obj].TotalByteLength += object[obj].counter_data.ByteLength;
                }
-               object[obj].HeaderLength = sizeof(*object) - (sizeof(counter) + sizeof(instance) + sizeof(PERF_COUNTER_BLOCK));
+               object[obj].HeaderLength = sizeof(*object) - (sizeof(counter) + sizeof(instance) + sizeof(struct PERF_COUNTER_BLOCK));
                object[obj].TotalByteLength += object[obj].HeaderLength;
                object[obj].DefinitionLength += object[obj].HeaderLength;
 
@@ -1037,10 +1060,11 @@ static uint32 _reg_perfcount_perf_data_block_fixup(PERF_DATA_BLOCK *block, prs_s
 /*********************************************************************
 *********************************************************************/
 
-uint32 reg_perfcount_get_perf_data_block(uint32 base_index, 
-                                        prs_struct *ps, 
-                                        PERF_DATA_BLOCK *block,
-                                        const char *object_ids)
+static uint32 reg_perfcount_get_perf_data_block(uint32 base_index,
+                                               TALLOC_CTX *mem_ctx,
+                                               struct PERF_DATA_BLOCK *block,
+                                               const char *object_ids,
+                                               bool bigendian_data)
 {
        uint32 buffer_size = 0;
        const char *fname = counters_directory( NAMES_DB );
@@ -1055,7 +1079,7 @@ uint32 reg_perfcount_get_perf_data_block(uint32 base_index,
                return 0;
        }
 
-       if (!_reg_perfcount_init_data_block(block, ps, names)) {
+       if (!_reg_perfcount_init_data_block(block, mem_ctx, names, bigendian_data)) {
                DEBUG(0, ("_reg_perfcount_init_data_block failed\n"));
                tdb_close(names);
                return 0;
@@ -1066,14 +1090,14 @@ uint32 reg_perfcount_get_perf_data_block(uint32 base_index,
        if(object_ids == NULL)
        {
                /* we're getting a request for "Global" here */
-               retval = _reg_perfcount_assemble_global(block, ps, base_index, names);
+               retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
        }
        else
        {
                /* we're getting a request for a specific set of PERF_OBJECT_TYPES */
-               retval = _reg_perfcount_assemble_global(block, ps, base_index, names);
+               retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
        }
-       buffer_size = _reg_perfcount_perf_data_block_fixup(block, ps);
+       buffer_size = _reg_perfcount_perf_data_block_fixup(block, mem_ctx);
 
        tdb_close(names);
 
@@ -1084,10 +1108,35 @@ uint32 reg_perfcount_get_perf_data_block(uint32 base_index,
        return buffer_size + block->HeaderLength;
 }
 
+/*******************************************************************
+********************************************************************/
+
+static bool smb_io_system_time(const char *desc, prs_struct *ps, int depth, struct SYSTEMTIME *systime)
+{
+       if(!prs_uint16("year", ps, depth, &systime->year))
+               return False;
+       if(!prs_uint16("month", ps, depth, &systime->month))
+               return False;
+       if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
+               return False;
+       if(!prs_uint16("day", ps, depth, &systime->day))
+               return False;
+       if(!prs_uint16("hour", ps, depth, &systime->hour))
+               return False;
+       if(!prs_uint16("minute", ps, depth, &systime->minute))
+               return False;
+       if(!prs_uint16("second", ps, depth, &systime->second))
+               return False;
+       if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
+               return False;
+
+       return True;
+}
+
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_marshall_perf_data_block(prs_struct *ps, PERF_DATA_BLOCK block, int depth)
+static bool _reg_perfcount_marshall_perf_data_block(prs_struct *ps, struct PERF_DATA_BLOCK block, int depth)
 {
        int i;
        prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_data_block");
@@ -1142,11 +1191,11 @@ static bool _reg_perfcount_marshall_perf_data_block(prs_struct *ps, PERF_DATA_BL
 *********************************************************************/
 
 static bool _reg_perfcount_marshall_perf_counters(prs_struct *ps,
-                                                 PERF_OBJECT_TYPE object,
+                                                 struct PERF_OBJECT_TYPE object,
                                                  int depth)
 {
        int cnt;
-       PERF_COUNTER_DEFINITION counter;
+       struct PERF_COUNTER_DEFINITION counter;
 
        prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_counters");
        depth++;
@@ -1186,7 +1235,7 @@ static bool _reg_perfcount_marshall_perf_counters(prs_struct *ps,
 *********************************************************************/
 
 static bool _reg_perfcount_marshall_perf_counter_data(prs_struct *ps, 
-                                                     PERF_COUNTER_BLOCK counter_data, 
+                                                     struct PERF_COUNTER_BLOCK counter_data,
                                                      int depth)
 {
        prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_counter_data");
@@ -1209,10 +1258,10 @@ static bool _reg_perfcount_marshall_perf_counter_data(prs_struct *ps,
 *********************************************************************/
 
 static bool _reg_perfcount_marshall_perf_instances(prs_struct *ps,
-                                                  PERF_OBJECT_TYPE object, 
+                                                  struct PERF_OBJECT_TYPE object,
                                                   int depth)
 {
-       PERF_INSTANCE_DEFINITION instance;
+       struct PERF_INSTANCE_DEFINITION instance;
        int inst;
 
        prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_instances");
@@ -1249,11 +1298,11 @@ static bool _reg_perfcount_marshall_perf_instances(prs_struct *ps,
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_marshall_perf_objects(prs_struct *ps, PERF_DATA_BLOCK block, int depth)
+static bool _reg_perfcount_marshall_perf_objects(prs_struct *ps, struct PERF_DATA_BLOCK block, int depth)
 {
        int obj;
 
-       PERF_OBJECT_TYPE object;
+       struct PERF_OBJECT_TYPE object;
 
        prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_objects");
        depth++;
@@ -1319,20 +1368,6 @@ static bool _reg_perfcount_marshall_perf_objects(prs_struct *ps, PERF_DATA_BLOCK
 /*********************************************************************
 *********************************************************************/
 
-static bool _reg_perfcount_marshall_hkpd(prs_struct *ps, PERF_DATA_BLOCK block)
-{
-       int depth = 0;
-       if(_reg_perfcount_marshall_perf_data_block(ps, block, depth) == True)
-       {
-               if(_reg_perfcount_marshall_perf_objects(ps, block, depth) == True)
-                       return True;
-       }
-       return False;
-}
-
-/*********************************************************************
-*********************************************************************/
-
 WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32 max_buf_size, uint32 *outbuf_len, const char *object_ids)
 {
        /*
@@ -1343,27 +1378,33 @@ WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32 max_buf_size, uint32 *outbu
         * promising under
         * http://msdn2.microsoft.com/en-us/library/aa373105.aspx -- vl
         */
-       PERF_DATA_BLOCK block;
+       struct PERF_DATA_BLOCK block;
        uint32 buffer_size, base_index; 
 
        buffer_size = 0;
        base_index = reg_perfcount_get_base_index();
        ZERO_STRUCT(block);
 
-       buffer_size = reg_perfcount_get_perf_data_block(base_index, ps, &block, object_ids);
+       buffer_size = reg_perfcount_get_perf_data_block(base_index, ps->mem_ctx, &block, object_ids, ps->bigendian_data);
 
        if(buffer_size < max_buf_size)
        {
                *outbuf_len = buffer_size;
-               if(_reg_perfcount_marshall_hkpd(ps, block) == True)
-                       return WERR_OK;
-               else
+
+               if (!_reg_perfcount_marshall_perf_data_block(ps, block, 0))
                        return WERR_NOMEM;
+
+               if (!_reg_perfcount_marshall_perf_objects(ps, block, 0))
+                       return WERR_NOMEM;
+
+               return WERR_OK;
        }
        else
        {
                *outbuf_len = max_buf_size;
-               _reg_perfcount_marshall_perf_data_block(ps, block, 0);
+               if (!_reg_perfcount_marshall_perf_data_block(ps, block, 0))
+                       return WERR_NOMEM;
+
                return WERR_INSUFFICIENT_BUFFER;
        }
 }    

diff --git a/source3/registry/reg_util.c b/source3/registry/reg_util.c
index 714a39f307a2adee3534598d5046c8d4f9021027..fd7652116f91d5b5d3c6ba030ebebb2a9cfe2549 100644 (file)
--- a/source3/registry/reg_util.c
+++ b/source3/registry/reg_util.c
@@ -158,110 +158,3 @@ char *reg_remaining_path(TALLOC_CTX *ctx, const char *key)
 
        return p;
 }
-
-/**********************************************************************
-*********************************************************************/
-
-int regval_convert_multi_sz( uint16 *multi_string, size_t byte_len, char ***values )
-{
-       char **sz;
-       int i;
-       int num_strings = 0;
-       fstring buffer;
-       uint16 *wp;
-       size_t multi_len = byte_len / 2;
-
-       if ( !multi_string || !values )
-               return 0;
-
-       *values = NULL;
-
-       /* just count the NULLs */
-
-       for ( i=0; (i<multi_len-1) && !(multi_string[i]==0x0 && multi_string[i+1]==0x0); i++ ) {
-               /* peek ahead */
-               if ( multi_string[i+1] == 0x0 )
-                       num_strings++;
-       }
-
-       if ( num_strings == 0 )
-               return 0;
-
-       if ( !(sz = TALLOC_ARRAY( NULL, char*, num_strings+1 )) ) {
-               DEBUG(0,("reg_convert_multi_sz: talloc() failed!\n"));
-               return -1;
-       }
-
-       wp = multi_string;
-
-       for ( i=0; i<num_strings; i++ ) {
-               rpcstr_pull( buffer, wp, sizeof(buffer), -1, STR_TERMINATE );
-               sz[i] = talloc_strdup( sz, buffer );
-
-               /* skip to the next string NULL and then one more */
-               while ( *wp )
-                       wp++;
-               wp++;
-       }
-
-       /* tag the array off with an empty string */
-       sz[i] = '\0';
-
-       *values = sz;
-
-       return num_strings;
-}
-
-/**********************************************************************
- Returns number of bytes, not number of unicode characters
-*********************************************************************/
-
-size_t regval_build_multi_sz( char **values, uint16 **buffer )
-{
-       int i;
-       size_t buf_size = 0;
-       uint16 *buf, *b;
-       UNISTR2 sz;
-
-       if ( !values || !buffer )
-               return 0;
-
-       /* go ahead and alloc some space */
-
-       if ( !(buf = TALLOC_ARRAY( NULL, uint16, 2 )) ) {
-               DEBUG(0,("regval_build_multi_sz: talloc() failed!\n"));
-               return 0;
-       }
-
-       for ( i=0; values[i]; i++ ) {
-               ZERO_STRUCT( sz );
-               /* DEBUG(0,("regval_build_multi_sz: building [%s]\n",values[i])); */
-               init_unistr2( &sz, values[i], UNI_STR_TERMINATE );
-
-               /* Alloc some more memory.  Always add one one to account for the 
-                  double NULL termination */
-
-               b = TALLOC_REALLOC_ARRAY( NULL, buf, uint16, buf_size+sz.uni_str_len+1 );
-               if ( !b ) {
-                       DEBUG(0,("regval_build_multi_sz: talloc() reallocation error!\n"));
-                       TALLOC_FREE( buffer );
-                       return 0;
-               }
-               buf = b;
-
-               /* copy the unistring2 buffer and increment the size */
-               /* dump_data(1,sz.buffer,sz.uni_str_len*2); */
-               memcpy( buf+buf_size, sz.buffer, sz.uni_str_len*2 );
-               buf_size += sz.uni_str_len;
-
-               /* cleanup rather than leaving memory hanging around */
-               TALLOC_FREE( sz.buffer );
-       }
-
-       buf[buf_size++] = 0x0;
-
-       *buffer = buf;
-
-       /* return number of bytes */
-       return buf_size*2;
-}

diff --git a/source3/rpc_client/cli_netlogon.c b/source3/rpc_client/cli_netlogon.c
index 911a50f39327483647a398dacc87949c52ab21e7..191a0b0126ed00ed4ded38d887d8e00339cfec80 100644 (file)
--- a/source3/rpc_client/cli_netlogon.c
+++ b/source3/rpc_client/cli_netlogon.c
@@ -509,33 +509,35 @@ NTSTATUS rpccli_netlogon_sam_network_logon_ex(struct rpc_pipe_client *cli,
 
 NTSTATUS rpccli_netlogon_set_trust_password(struct rpc_pipe_client *cli,
                                            TALLOC_CTX *mem_ctx,
+                                           const char *account_name,
                                            const unsigned char orig_trust_passwd_hash[16],
                                            const char *new_trust_pwd_cleartext,
                                            const unsigned char new_trust_passwd_hash[16],
-                                           uint32_t sec_channel_type)
+                                           enum netr_SchannelType sec_channel_type)
 {
        NTSTATUS result;
-       uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
        struct netr_Authenticator clnt_creds, srv_cred;
 
-       result = rpccli_netlogon_setup_creds(cli,
-                                            cli->desthost, /* server name */
-                                            lp_workgroup(), /* domain */
-                                            global_myname(), /* client name */
-                                            global_myname(), /* machine account name */
-                                            orig_trust_passwd_hash,
-                                            sec_channel_type,
-                                            &neg_flags);
-
-       if (!NT_STATUS_IS_OK(result)) {
-               DEBUG(3,("rpccli_netlogon_set_trust_password: unable to setup creds (%s)!\n",
-                        nt_errstr(result)));
-               return result;
+       if (!cli->dc) {
+               uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
+               result = rpccli_netlogon_setup_creds(cli,
+                                                    cli->desthost, /* server name */
+                                                    lp_workgroup(), /* domain */
+                                                    global_myname(), /* client name */
+                                                    account_name, /* machine account name */
+                                                    orig_trust_passwd_hash,
+                                                    sec_channel_type,
+                                                    &neg_flags);
+               if (!NT_STATUS_IS_OK(result)) {
+                       DEBUG(3,("rpccli_netlogon_set_trust_password: unable to setup creds (%s)!\n",
+                                nt_errstr(result)));
+                       return result;
+               }
        }
 
        netlogon_creds_client_authenticator(cli->dc, &clnt_creds);
 
-       if (neg_flags & NETLOGON_NEG_PASSWORD_SET2) {
+       if (cli->dc->negotiate_flags & NETLOGON_NEG_PASSWORD_SET2) {
 
                struct netr_CryptPassword new_password;
 

diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c
index 34b861690704c4edf3a54349218a866c422501be..c197bd4929c181fe400770c7b23327f99ebea23a 100644 (file)
--- a/source3/rpc_client/cli_pipe.c
+++ b/source3/rpc_client/cli_pipe.c
@@ -3819,7 +3819,7 @@ static NTSTATUS get_schannel_session_key_common(struct rpc_pipe_client *netlogon
                                                const char *domain,
                                                uint32 *pneg_flags)
 {
-       uint32 sec_chan_type = 0;
+       enum netr_SchannelType sec_chan_type = 0;
        unsigned char machine_pwd[16];
        const char *machine_account;
        NTSTATUS status;
@@ -3940,11 +3940,6 @@ NTSTATUS cli_rpc_pipe_open_schannel_with_key(struct cli_state *cli,
         * in - reference them in
         */
        result->dc = talloc_move(result, pdc);
-       if (result->dc == NULL) {
-               DEBUG(0, ("talloc reference failed\n"));
-               TALLOC_FREE(result);
-               return NT_STATUS_NO_MEMORY;
-       }
 
        DEBUG(10,("cli_rpc_pipe_open_schannel_with_key: opened pipe %s to machine %s "
                  "for domain %s and bound using schannel.\n",

diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c
deleted file mode 100644 (file)
index ec200a2..0000000
--- a/source3/rpc_client/cli_reg.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   RPC Pipe client
- 
-   Copyright (C) Gerald (Jerry) Carter        2005-2006
-   
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "rpc_client.h"
-
-/*******************************************************************
- connect to a registry hive root (open a registry policy)
-*******************************************************************/
-
-NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
-                         uint32 reg_type, uint32 access_mask,
-                         struct policy_handle *reg_hnd)
-{
-       ZERO_STRUCTP(reg_hnd);
-
-       switch (reg_type)
-       {
-       case HKEY_CLASSES_ROOT:
-               return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL, 
-                       access_mask, reg_hnd, NULL);
-
-       case HKEY_LOCAL_MACHINE:
-               return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL, 
-                       access_mask, reg_hnd, NULL);
-
-       case HKEY_USERS:
-               return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL, 
-                       access_mask, reg_hnd, NULL);
-
-       case HKEY_CURRENT_USER:
-               return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL, 
-                       access_mask, reg_hnd, NULL);
-
-       case HKEY_PERFORMANCE_DATA:
-               return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL, 
-                       access_mask, reg_hnd, NULL);
-
-       default:
-               /* fall through to end of function */
-               break;
-       }
-
-       return NT_STATUS_INVALID_PARAMETER;
-}

diff --git a/source3/rpc_client/cli_samr.c b/source3/rpc_client/cli_samr.c
index 5a0dff296595dc80855440002683053bc0e48dd7..df22ecb2844537a880dd97fa99ed5d5584b92e99 100644 (file)
--- a/source3/rpc_client/cli_samr.c
+++ b/source3/rpc_client/cli_samr.c
@@ -187,7 +187,7 @@ NTSTATUS rpccli_samr_chgpasswd_user3(struct rpc_pipe_client *cli,
                                     const char *newpassword,
                                     const char *oldpassword,
                                     struct samr_DomInfo1 **dominfo1,
-                                    struct samr_ChangeReject **reject)
+                                    struct userPwdChangeFailureInformation **reject)
 {
        NTSTATUS status;
 

diff --git a/source3/rpc_parse/parse_misc.c b/source3/rpc_parse/parse_misc.c
index 1ea4ecf46f8eb5b53dc0376e9855cea8a70a9760..c000923b9e13f1aa3b89944e152bee695674bd37 100644 (file)
--- a/source3/rpc_parse/parse_misc.c
+++ b/source3/rpc_parse/parse_misc.c
@@ -58,48 +58,6 @@ bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
        return True;
 }
 
-/*******************************************************************
-********************************************************************/
-
-bool smb_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
-{
-       if(!prs_uint16("year", ps, depth, &systime->year))
-               return False;
-       if(!prs_uint16("month", ps, depth, &systime->month))
-               return False;
-       if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
-               return False;
-       if(!prs_uint16("day", ps, depth, &systime->day))
-               return False;
-       if(!prs_uint16("hour", ps, depth, &systime->hour))
-               return False;
-       if(!prs_uint16("minute", ps, depth, &systime->minute))
-               return False;
-       if(!prs_uint16("second", ps, depth, &systime->second))
-               return False;
-       if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
-               return False;
-
-       return True;
-}
-
-/*******************************************************************
-********************************************************************/
-
-bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
-{
-       systime->year=unixtime->tm_year+1900;
-       systime->month=unixtime->tm_mon+1;
-       systime->dayofweek=unixtime->tm_wday;
-       systime->day=unixtime->tm_mday;
-       systime->hour=unixtime->tm_hour;
-       systime->minute=unixtime->tm_min;
-       systime->second=unixtime->tm_sec;
-       systime->milliseconds=0;
-
-       return True;
-}
-
 /*******************************************************************
  Reads or writes a struct GUID
 ********************************************************************/
@@ -127,59 +85,3 @@ bool smb_io_uuid(const char *desc, struct GUID *uuid,
 
        return True;
 }
-
-/*******************************************************************
- Inits a UNISTR2 structure.
-********************************************************************/
-
-void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
-{
-       size_t len = 0;
-       uint32 num_chars = 0;
-
-       if (buf) {
-               /* We always null terminate the copy. */
-               len = strlen(buf) + 1;
-               if ( flags == UNI_STR_DBLTERMINATE )
-                       len++;
-       }
-
-       if (buf == NULL || len == 0) {
-               /* no buffer -- nothing to do */
-               str->uni_max_len = 0;
-               str->offset = 0;
-               str->uni_str_len = 0;
-
-               return;
-       }
-       
-
-       str->buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, len);
-       if (str->buffer == NULL) {
-               smb_panic("init_unistr2: malloc fail");
-               return;
-       }
-
-       /* Ensure len is the length in *bytes* */
-       len *= sizeof(uint16);
-
-       /*
-        * The UNISTR2 must be initialized !!!
-        * jfm, 7/7/2001.
-        */
-       if (buf) {
-               rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
-               num_chars = strlen_w(str->buffer);
-               if (flags == UNI_STR_TERMINATE || flags == UNI_MAXLEN_TERMINATE) {
-                       num_chars++;
-               }
-               if ( flags == UNI_STR_DBLTERMINATE )
-                       num_chars += 2;
-       }
-
-       str->uni_max_len = num_chars;
-       str->offset = 0;
-       str->uni_str_len = num_chars;
-       if ( num_chars && ((flags == UNI_MAXLEN_TERMINATE) || (flags == UNI_BROKEN_NON_NULL)) )
-               str->uni_max_len++;
-}

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index edccded6c6c5f6281b7257af1d99f3caac1bcfd6..aade037f895122286094f34eee87d11a548f75e3 100644 (file)
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1021,50 +1021,6 @@ bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
        return True;
 }
 
-
-/*******************************************************************
- Stream a null-terminated string.  len is strlen, and therefore does
- not include the null-termination character.
- ********************************************************************/
-
-bool prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
-{
-       char *q;
-       int i;
-       int len;
-
-       if (UNMARSHALLING(ps))
-               len = strlen(&ps->data_p[ps->data_offset]);
-       else
-               len = strlen(str);
-
-       len = MIN(len, (max_buf_size-1));
-
-       q = prs_mem_get(ps, len+1);
-       if (q == NULL)
-               return False;
-
-       for(i = 0; i < len; i++) {
-               if (UNMARSHALLING(ps))
-                       str[i] = q[i];
-               else
-                       q[i] = str[i];
-       }
-
-       /* The terminating null. */
-       str[i] = '\0';
-
-       if (MARSHALLING(ps)) {
-               q[i] = '\0';
-       }
-
-       ps->data_offset += len+1;
-
-       dump_data(5+depth, (uint8 *)q, len);
-
-       return True;
-}
-
 /*******************************************************************
 creates a new prs_struct containing a DATA_BLOB
 ********************************************************************/

diff --git a/source3/rpc_server/srv_netlog_nt.c b/source3/rpc_server/srv_netlog_nt.c
index 9169c74534acafa757b25dac7c6fb3cc63f40d2e..491754f76a77891140dc4659a6940b81951551c0 100644 (file)
--- a/source3/rpc_server/srv_netlog_nt.c
+++ b/source3/rpc_server/srv_netlog_nt.c
@@ -116,103 +116,105 @@ WERROR _netr_LogonControl2Ex(pipes_struct *p,
        const char *fn;
 
        switch (p->hdr_req.opnum) {
-               case NDR_NETR_LOGONCONTROL:
-                       fn = "_netr_LogonControl";
-                       break;
-               case NDR_NETR_LOGONCONTROL2:
-                       fn = "_netr_LogonControl2";
-                       break;
-               case NDR_NETR_LOGONCONTROL2EX:
-                       fn = "_netr_LogonControl2Ex";
-                       break;
-               default:
-                       return WERR_INVALID_PARAM;
+       case NDR_NETR_LOGONCONTROL:
+               fn = "_netr_LogonControl";
+               break;
+       case NDR_NETR_LOGONCONTROL2:
+               fn = "_netr_LogonControl2";
+               break;
+       case NDR_NETR_LOGONCONTROL2EX:
+               fn = "_netr_LogonControl2Ex";
+               break;
+       default:
+               return WERR_INVALID_PARAM;
        }
 
        tc_status = WERR_NO_SUCH_DOMAIN;
 
        switch (r->in.function_code) {
-               case NETLOGON_CONTROL_TC_QUERY:
-                       domain = r->in.data->domain;
+       case NETLOGON_CONTROL_TC_QUERY:
+               domain = r->in.data->domain;
 
-                       if ( !is_trusted_domain( domain ) )
-                               break;
+               if (!is_trusted_domain(domain)) {
+                       break;
+               }
 
-                       if ( !get_dc_name( domain, NULL, dc_name2, &dc_ss ) ) {
-                               tc_status = WERR_NO_LOGON_SERVERS;
-                               break;
-                       }
+               if (!get_dc_name(domain, NULL, dc_name2, &dc_ss)) {
+                       tc_status = WERR_NO_LOGON_SERVERS;
+                       break;
+               }
 
-                       dc_name = talloc_asprintf(p->mem_ctx, "\\\\%s", dc_name2);
-                       if (!dc_name) {
-                               return WERR_NOMEM;
-                       }
+               dc_name = talloc_asprintf(p->mem_ctx, "\\\\%s", dc_name2);
+               if (!dc_name) {
+                       return WERR_NOMEM;
+               }
 
-                       tc_status = WERR_OK;
+               tc_status = WERR_OK;
 
-                       break;
+               break;
 
-               case NETLOGON_CONTROL_REDISCOVER:
-                       domain = r->in.data->domain;
+       case NETLOGON_CONTROL_REDISCOVER:
+               domain = r->in.data->domain;
 
-                       if ( !is_trusted_domain( domain ) )
-                               break;
+               if (!is_trusted_domain(domain)) {
+                       break;
+               }
 
-                       if ( !get_dc_name( domain, NULL, dc_name2, &dc_ss ) ) {
-                               tc_status = WERR_NO_LOGON_SERVERS;
-                               break;
-                       }
+               if (!get_dc_name(domain, NULL, dc_name2, &dc_ss)) {
+                       tc_status = WERR_NO_LOGON_SERVERS;
+                       break;
+               }
 
-                       dc_name = talloc_asprintf(p->mem_ctx, "\\\\%s", dc_name2);
-                       if (!dc_name) {
-                               return WERR_NOMEM;
-                       }
+               dc_name = talloc_asprintf(p->mem_ctx, "\\\\%s", dc_name2);
+               if (!dc_name) {
+                       return WERR_NOMEM;
+               }
 
-                       tc_status = WERR_OK;
+               tc_status = WERR_OK;
 
-                       break;
+               break;
 
-               default:
-                       /* no idea what this should be */
-                       DEBUG(0,("%s: unimplemented function level [%d]\n",
-                               fn, r->in.function_code));
-                       return WERR_UNKNOWN_LEVEL;
+       default:
+               /* no idea what this should be */
+               DEBUG(0,("%s: unimplemented function level [%d]\n",
+                       fn, r->in.function_code));
+               return WERR_UNKNOWN_LEVEL;
        }
 
        /* prepare the response */
 
        switch (r->in.level) {
-               case 1:
-                       info1 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_1);
-                       W_ERROR_HAVE_NO_MEMORY(info1);
+       case 1:
+               info1 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_1);
+               W_ERROR_HAVE_NO_MEMORY(info1);
 
-                       info1->flags                    = flags;
-                       info1->pdc_connection_status    = pdc_connection_status;
+               info1->flags                    = flags;
+               info1->pdc_connection_status    = pdc_connection_status;
 
-                       r->out.query->info1 = info1;
-                       break;
-               case 2:
-                       info2 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_2);
-                       W_ERROR_HAVE_NO_MEMORY(info2);
+               r->out.query->info1 = info1;
+               break;
+       case 2:
+               info2 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_2);
+               W_ERROR_HAVE_NO_MEMORY(info2);
 
-                       info2->flags                    = flags;
-                       info2->pdc_connection_status    = pdc_connection_status;
-                       info2->trusted_dc_name          = dc_name;
-                       info2->tc_connection_status     = tc_status;
+               info2->flags                    = flags;
+               info2->pdc_connection_status    = pdc_connection_status;
+               info2->trusted_dc_name          = dc_name;
+               info2->tc_connection_status     = tc_status;
 
-                       r->out.query->info2 = info2;
-                       break;
-               case 3:
-                       info3 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_3);
-                       W_ERROR_HAVE_NO_MEMORY(info3);
+               r->out.query->info2 = info2;
+               break;
+       case 3:
+               info3 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_3);
+               W_ERROR_HAVE_NO_MEMORY(info3);
 
-                       info3->flags                    = flags;
-                       info3->logon_attempts           = logon_attempts;
+               info3->flags                    = flags;
+               info3->logon_attempts           = logon_attempts;
 
-                       r->out.query->info3 = info3;
-                       break;
-               default:
-                       return WERR_UNKNOWN_LEVEL;
+               r->out.query->info3 = info3;
+               break;
+       default:
+               return WERR_UNKNOWN_LEVEL;
        }
 
         if (lp_server_role() == ROLE_DOMAIN_BDC) {
@@ -229,20 +231,47 @@ WERROR _netr_LogonControl2Ex(pipes_struct *p,
 WERROR _netr_NetrEnumerateTrustedDomains(pipes_struct *p,
                                         struct netr_NetrEnumerateTrustedDomains *r)
 {
-       struct netr_Blob trusted_domains_blob;
+       NTSTATUS status;
        DATA_BLOB blob;
+       struct trustdom_info **domains;
+       uint32_t num_domains;
+       const char **trusted_domains;
+       int i;
 
        DEBUG(6,("_netr_NetrEnumerateTrustedDomains: %d\n", __LINE__));
 
        /* set up the Trusted Domain List response */
 
-       blob = data_blob_talloc_zero(p->mem_ctx, 2);
-       trusted_domains_blob.data = blob.data;
-       trusted_domains_blob.length = blob.length;
+       become_root();
+       status = pdb_enum_trusteddoms(p->mem_ctx, &num_domains, &domains);
+       unbecome_root();
 
-       DEBUG(6,("_netr_NetrEnumerateTrustedDomains: %d\n", __LINE__));
+       if (!NT_STATUS_IS_OK(status)) {
+               return ntstatus_to_werror(status);
+       }
+
+       trusted_domains = talloc_zero_array(p->mem_ctx, const char *, num_domains + 1);
+       if (!trusted_domains) {
+               return WERR_NOMEM;
+       }
+
+       for (i = 0; i < num_domains; i++) {
+               trusted_domains[i] = talloc_strdup(trusted_domains, domains[i]->name);
+               if (!trusted_domains[i]) {
+                       TALLOC_FREE(trusted_domains);
+                       return WERR_NOMEM;
+               }
+       }
+
+       if (!push_reg_multi_sz(trusted_domains, &blob, trusted_domains)) {
+               TALLOC_FREE(trusted_domains);
+               return WERR_NOMEM;
+       }
 
-       *r->out.trusted_domains_blob = trusted_domains_blob;
+       r->out.trusted_domains_blob->data = blob.data;
+       r->out.trusted_domains_blob->length = blob.length;
+
+       DEBUG(6,("_netr_NetrEnumerateTrustedDomains: %d\n", __LINE__));
 
        return WERR_OK;
 }
@@ -252,7 +281,7 @@ WERROR _netr_NetrEnumerateTrustedDomains(pipes_struct *p,
  ******************************************************************/
 
 static NTSTATUS get_md4pw(struct samr_Password *md4pw, const char *mach_acct,
-                         uint16_t sec_chan_type, struct dom_sid *sid)
+                         enum netr_SchannelType sec_chan_type, struct dom_sid *sid)
 {
        struct samu *sampass = NULL;
        const uint8 *pass;
@@ -798,6 +827,7 @@ NTSTATUS _netr_ServerPasswordSet2(pipes_struct *p,
        struct samu *sampass;
        DATA_BLOB plaintext;
        struct samr_CryptPassword password_buf;
+       struct samr_Password nt_hash;
 
        become_root();
        status = netr_creds_server_step_check(p, p->mem_ctx,
@@ -823,6 +853,8 @@ NTSTATUS _netr_ServerPasswordSet2(pipes_struct *p,
                return NT_STATUS_WRONG_PASSWORD;
        }
 
+       mdfour(nt_hash.hash, plaintext.data, plaintext.length);
+
        status = netr_find_machine_account(p->mem_ctx,
                                           creds->account_name,
                                           &sampass);
@@ -832,8 +864,8 @@ NTSTATUS _netr_ServerPasswordSet2(pipes_struct *p,
 
        status = netr_set_machine_account_password(sampass,
                                                   sampass,
-                                                  &plaintext,
                                                   NULL,
+                                                  &nt_hash,
                                                   NULL);
        TALLOC_FREE(sampass);
        return status;

diff --git a/source3/rpc_server/srv_ntsvcs_nt.c b/source3/rpc_server/srv_ntsvcs_nt.c
index 553707bfe5f55db76b258436db079b94d381eec7..357478f274dba0a62f07b8364755f8279f5ef05f 100644 (file)
--- a/source3/rpc_server/srv_ntsvcs_nt.c
+++ b/source3/rpc_server/srv_ntsvcs_nt.c
@@ -76,9 +76,8 @@ WERROR _PNP_GetDeviceList(pipes_struct *p,
 {
        char *devicepath;
        uint32_t size = 0;
-       char **multi_sz = NULL;
-       size_t multi_sz_len;
-       uint16_t *multi_sz_buf;
+       const char **multi_sz = NULL;
+       DATA_BLOB blob;
 
        if ((r->in.flags & CM_GETIDLIST_FILTER_SERVICE) &&
            (!r->in.filter)) {
@@ -95,23 +94,22 @@ WERROR _PNP_GetDeviceList(pipes_struct *p,
                return WERR_CM_BUFFER_SMALL;
        }
 
-       multi_sz = talloc_zero_array(p->mem_ctx, char *, 2);
+       multi_sz = talloc_zero_array(p->mem_ctx, const char *, 2);
        if (!multi_sz) {
                return WERR_NOMEM;
        }
 
        multi_sz[0] = devicepath;
 
-       multi_sz_len = regval_build_multi_sz(multi_sz, &multi_sz_buf);
-       if (!multi_sz_len) {
+       if (!push_reg_multi_sz(multi_sz, &blob, multi_sz)) {
                return WERR_NOMEM;
        }
 
-       if (*r->in.length < multi_sz_len/2) {
+       if (*r->in.length < blob.length/2) {
                return WERR_CM_BUFFER_SMALL;
        }
 
-       memcpy(r->out.buffer, multi_sz_buf, multi_sz_len);
+       memcpy(r->out.buffer, blob.data, blob.length);
 
        return WERR_OK;
 }

diff --git a/source3/rpc_server/srv_pipe.c b/source3/rpc_server/srv_pipe.c
index 8611be49e31e112c6ea731f2089c3ab8923b218a..a246b6db50d6d795c37d893825d73c352975fe40 100644 (file)
--- a/source3/rpc_server/srv_pipe.c
+++ b/source3/rpc_server/srv_pipe.c
@@ -1092,6 +1092,7 @@ bool is_known_pipename(const char *cli_filename, struct ndr_syntax_id *syntax)
 {
        const char *pipename = cli_filename;
        int i;
+       NTSTATUS status;
 
        if (strnequal(pipename, "\\PIPE\\", 6)) {
                pipename += 5;
@@ -1113,7 +1114,27 @@ bool is_known_pipename(const char *cli_filename, struct ndr_syntax_id *syntax)
                }
        }
 
-       DEBUG(10, ("is_known_pipename: %s unknown\n", cli_filename));
+       status = smb_probe_module("rpc", pipename);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("is_known_pipename: %s unknown\n", cli_filename));
+               return false;
+       }
+       DEBUG(10, ("is_known_pipename: %s loaded dynamically\n", pipename));
+
+       /*
+        * Scan the list again for the interface id
+        */
+
+       for (i=0; i<rpc_lookup_size; i++) {
+               if (strequal(pipename, rpc_lookup[i].pipe.clnt)) {
+                       *syntax = rpc_lookup[i].rpc_interface;
+                       return true;
+               }
+       }
+
+       DEBUG(10, ("is_known_pipename: pipe %s did not register itself!\n",
+                  pipename));
+
        return false;
 }
 

diff --git a/source3/rpc_server/srv_samr_nt.c b/source3/rpc_server/srv_samr_nt.c
index 9e95c480330e2bbfc579b38b84c2875fb368e53b..10b7d42d4641890d65ae78b3859e695d0f321a50 100644 (file)
--- a/source3/rpc_server/srv_samr_nt.c
+++ b/source3/rpc_server/srv_samr_nt.c
@@ -2023,9 +2023,9 @@ NTSTATUS _samr_ChangePasswordUser3(pipes_struct *p,
        NTSTATUS status;
        fstring user_name;
        const char *wks = NULL;
-       uint32 reject_reason;
+       enum samPwdChangeReason reject_reason;
        struct samr_DomInfo1 *dominfo = NULL;
-       struct samr_ChangeReject *reject = NULL;
+       struct userPwdChangeFailureInformation *reject = NULL;
        uint32_t tmp;
 
        DEBUG(5,("_samr_ChangePasswordUser3: %d\n", __LINE__));
@@ -2070,7 +2070,8 @@ NTSTATUS _samr_ChangePasswordUser3(pipes_struct *p,
                        return NT_STATUS_NO_MEMORY;
                }
 
-               reject = TALLOC_ZERO_P(p->mem_ctx, struct samr_ChangeReject);
+               reject = TALLOC_ZERO_P(p->mem_ctx,
+                               struct userPwdChangeFailureInformation);
                if (!reject) {
                        return NT_STATUS_NO_MEMORY;
                }
@@ -2105,7 +2106,7 @@ NTSTATUS _samr_ChangePasswordUser3(pipes_struct *p,
                        dominfo->password_properties |= DOMAIN_PASSWORD_COMPLEX;
                }
 
-               reject->reason = reject_reason;
+               reject->extendedFailureReason = reject_reason;
 
                *r->out.dominfo = dominfo;
                *r->out.reject = reject;

diff --git a/source3/rpc_server/srv_spoolss_nt.c b/source3/rpc_server/srv_spoolss_nt.c
index a81b5772c019a4c30918a1f37a15e87df516b6a5..682a59b5a8e84d22ae06fcf3b73f31c700090b8a 100644 (file)
--- a/source3/rpc_server/srv_spoolss_nt.c
+++ b/source3/rpc_server/srv_spoolss_nt.c
@@ -6074,7 +6074,7 @@ static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
        NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
        Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
        WERROR result;
-       UNISTR2 buffer;
+       DATA_BLOB buffer;
        fstring asc_buffer;
 
        DEBUG(8,("update_printer\n"));
@@ -6184,17 +6184,17 @@ static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
         */
 
        if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
-               init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
+               push_reg_sz(talloc_tos(), &buffer, printer->info_2->comment);
                set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
-                       REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+                       REG_SZ, buffer.data, buffer.length);
 
                notify_printer_comment(snum, printer->info_2->comment);
        }
 
        if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
-               init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
+               push_reg_sz(talloc_tos(), &buffer, printer->info_2->sharename);
                set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
-                       REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+                       REG_SZ, buffer.data, buffer.length);
 
                notify_printer_sharename(snum, printer->info_2->sharename);
        }
@@ -6208,25 +6208,25 @@ static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
                        pname = printer->info_2->printername;
 
 
-               init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
+               push_reg_sz(talloc_tos(), &buffer, pname);
                set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
-                       REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+                       REG_SZ, buffer.data, buffer.length);
 
                notify_printer_printername( snum, pname );
        }
 
        if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
-               init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
+               push_reg_sz(talloc_tos(), &buffer, printer->info_2->portname);
                set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
-                       REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+                       REG_SZ, buffer.data, buffer.length);
 
                notify_printer_port(snum, printer->info_2->portname);
        }
 
        if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
-               init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
+               push_reg_sz(talloc_tos(), &buffer, printer->info_2->location);
                set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
-                       REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+                       REG_SZ, buffer.data, buffer.length);
 
                notify_printer_location(snum, printer->info_2->location);
        }
@@ -6234,17 +6234,17 @@ static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
        /* here we need to update some more DsSpooler keys */
        /* uNCName, serverName, shortServerName */
 
-       init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
+       push_reg_sz(talloc_tos(), &buffer, global_myname());
        set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
-               REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+               REG_SZ, buffer.data, buffer.length);
        set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
-               REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+               REG_SZ, buffer.data, buffer.length);
 
        slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
                  global_myname(), printer->info_2->sharename );
-       init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
+       push_reg_sz(talloc_tos(), &buffer, asc_buffer);
        set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
-               REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
+               REG_SZ, buffer.data, buffer.length);
 
        /* Update printer info */
        result = mod_a_printer(printer, 2);

diff --git a/source3/rpcclient/cmd_netlogon.c b/source3/rpcclient/cmd_netlogon.c
index ae76652113a7da9c28faed319e69a5f3862bead0..2fbadf2a75be6a034f0c9a02c9c3bd1f74afc163 100644 (file)
--- a/source3/rpcclient/cmd_netlogon.c
+++ b/source3/rpcclient/cmd_netlogon.c
@@ -1051,7 +1051,7 @@ static NTSTATUS cmd_netlogon_database_redo(struct rpc_pipe_client *cli,
        struct netr_Authenticator clnt_creds, srv_cred;
        struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
        unsigned char trust_passwd_hash[16];
-       uint32_t sec_channel_type = 0;
+       enum netr_SchannelType sec_channel_type = 0;
        struct netr_ChangeLogEntry e;
        uint32_t rid = 500;
 

diff --git a/source3/rpcclient/cmd_samr.c b/source3/rpcclient/cmd_samr.c
index 699b54d364f5333648bdcc744a5bdf0b52fac481..e52411f8f751e0bfd67555dc6e0d55e00b36a5fc 100644 (file)
--- a/source3/rpcclient/cmd_samr.c
+++ b/source3/rpcclient/cmd_samr.c
@@ -2538,7 +2538,7 @@ static NTSTATUS cmd_samr_chgpasswd3(struct rpc_pipe_client *cli,
        const char *user, *oldpass, *newpass;
        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
        struct samr_DomInfo1 *info = NULL;
-       struct samr_ChangeReject *reject = NULL;
+       struct userPwdChangeFailureInformation *reject = NULL;
 
        if (argc < 3) {
                printf("Usage: %s username oldpass newpass\n", argv[0]);
@@ -2581,22 +2581,19 @@ static NTSTATUS cmd_samr_chgpasswd3(struct rpc_pipe_client *cli,
 
                display_sam_dom_info_1(info);
 
-               switch (reject->reason) {
-                       case SAMR_REJECT_TOO_SHORT:
-                               d_printf("SAMR_REJECT_TOO_SHORT\n");
+               switch (reject->extendedFailureReason) {
+                       case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT:
+                               d_printf("SAM_PWD_CHANGE_PASSWORD_TOO_SHORT\n");
                                break;
-                       case SAMR_REJECT_IN_HISTORY:
-                               d_printf("SAMR_REJECT_IN_HISTORY\n");
+                       case SAM_PWD_CHANGE_PWD_IN_HISTORY:
+                               d_printf("SAM_PWD_CHANGE_PWD_IN_HISTORY\n");
                                break;
-                       case SAMR_REJECT_COMPLEXITY:
-                               d_printf("SAMR_REJECT_COMPLEXITY\n");
-                               break;
-                       case SAMR_REJECT_OTHER:
-                               d_printf("SAMR_REJECT_OTHER\n");
+                       case SAM_PWD_CHANGE_NOT_COMPLEX:
+                               d_printf("SAM_PWD_CHANGE_NOT_COMPLEX\n");
                                break;
                        default:
                                d_printf("unknown reject reason: %d\n",
-                                       reject->reason);
+                                       reject->extendedFailureReason);
                                break;
                }
        }

diff --git a/source3/rpcclient/cmd_spoolss.c b/source3/rpcclient/cmd_spoolss.c
index 48f9df3cacf71ef98cf80c9586a33fce67cc6d2c..8b1a6eac03624a7cf9d64ec9716176b497b855c5 100644 (file)
--- a/source3/rpcclient/cmd_spoolss.c
+++ b/source3/rpcclient/cmd_spoolss.c
@@ -689,7 +689,8 @@ static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
 
 static void display_reg_value(struct regval_blob value)
 {
-       char *text = NULL;
+       const char *text = NULL;
+       DATA_BLOB blob;
 
        switch(value.type) {
        case REG_DWORD:
@@ -697,11 +698,8 @@ static void display_reg_value(struct regval_blob value)
                       *((uint32_t *) value.data_p));
                break;
        case REG_SZ:
-               rpcstr_pull_talloc(talloc_tos(),
-                               &text,
-                               value.data_p,
-                               value.size,
-                               STR_TERMINATE);
+               blob = data_blob_const(value.data_p, value.size);
+               pull_reg_sz(talloc_tos(), &blob, &text);
                printf("%s: REG_SZ: %s\n", value.valuename, text ? text : "");
                break;
        case REG_BINARY: {
@@ -723,18 +721,17 @@ static void display_reg_value(struct regval_blob value)
                break;
        }
        case REG_MULTI_SZ: {
-               uint32_t i, num_values;
-               char **values;
+               uint32_t i;
+               const char **values;
+               blob = data_blob_const(value.data_p, value.size);
 
-               if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
-                                                    value.size, &num_values,
-                                                    &values))) {
-                       d_printf("reg_pull_multi_sz failed\n");
+               if (!pull_reg_multi_sz(NULL, &blob, &values)) {
+                       d_printf("pull_reg_multi_sz failed\n");
                        break;
                }
 
                printf("%s: REG_MULTI_SZ: \n", value.valuename);
-               for (i=0; i<num_values; i++) {
+               for (i=0; values[i] != NULL; i++) {
                        d_printf("%s\n", values[i]);
                }
                TALLOC_FREE(values);

diff --git a/source3/rpcclient/rpcclient.c b/source3/rpcclient/rpcclient.c
index 7a20e487f27777e609aae3e4f511558f2c34a67b..20ea8a05e7d3ad9460a52e0d59320253e67a3bb3 100644 (file)
--- a/source3/rpcclient/rpcclient.c
+++ b/source3/rpcclient/rpcclient.c
@@ -694,7 +694,7 @@ static NTSTATUS do_cmd(struct cli_state *cli,
                if (ndr_syntax_id_equal(cmd_entry->interface,
                                        &ndr_table_netlogon.syntax_id)) {
                        uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
-                       uint32 sec_channel_type;
+                       enum netr_SchannelType sec_channel_type;
                        uchar trust_password[16];
                        const char *machine_account;
 

diff --git a/source3/script/tests/selftest.sh b/source3/script/tests/selftest.sh
index ae856ca31e0b36d17f84012af749311cf3ec4e6b..43e7bf173181b0886194efc788e6003714438b48 100755 (executable)
--- a/source3/script/tests/selftest.sh
+++ b/source3/script/tests/selftest.sh
@@ -57,7 +57,15 @@ export TORTURE_MAXTIME
 WORKGROUP=SAMBA-TEST
 SERVER=localhost2
 SERVER_IP=127.0.0.2
-USERNAME=`PATH=/usr/ucb:$PATH whoami`
+if [ ! "x$USER" = "x" ]; then
+    USERNAME=$USER
+else
+    if [ ! "x$LOGNAME" = "x" ]; then
+        USERNAME=$LOGNAME
+    else
+        USERNAME=`PATH=/usr/ucb:$PATH whoami || id -un`
+    fi
+fi
 USERID=`PATH=/usr/ucb:$PATH id | cut -d ' ' -f1 | sed -e 's/uid=\([0-9]*\).*/\1/g'`
 GROUPID=`PATH=/usr/ucb:$PATH id | cut -d ' ' -f2 | sed -e 's/gid=\([0-9]*\).*/\1/g'`
 PASSWORD=test

diff --git a/source3/script/tests/test_posix_s3.sh b/source3/script/tests/test_posix_s3.sh
index 48ea2f66ccf6f2a4d97dd1c6a414049d65c4aed6..cfa6d5ad02b300e48c6bde5725d229e3cf3f49fc 100755 (executable)
--- a/source3/script/tests/test_posix_s3.sh
+++ b/source3/script/tests/test_posix_s3.sh
@@ -48,12 +48,14 @@ rpc="$rpc RPC-NETLOGON-S3 RPC-SCHANNEL RPC-SCHANNEL2 RPC-BENCH-SCHANNEL1 RPC-JOI
 
 local="LOCAL-NSS-WRAPPER"
 
+winbind="WINBIND-WBCLIENT"
+
 # NOTE: to enable the UNIX-WHOAMI test, we need to change the default share
 # config to allow guest access. I'm not sure whether this would break other
 # tests, so leaving it alone for now -- jpeach
 unix="UNIX-INFO2"
 
-tests="$base $raw $rpc $unix $local"
+tests="$base $raw $rpc $unix $local $winbind"
 
 if test "x$POSIX_SUBTESTS" != "x" ; then
        tests="$POSIX_SUBTESTS"

diff --git a/source3/script/tests/test_smbclient_s3.sh b/source3/script/tests/test_smbclient_s3.sh
index f60c7d7c0b8237b6ccf4c022cbb19b70038124bb..f10bfeac3946bac03ccb9fafb4c91deb0d5dfb19 100755 (executable)
--- a/source3/script/tests/test_smbclient_s3.sh
+++ b/source3/script/tests/test_smbclient_s3.sh
@@ -86,6 +86,46 @@ EOF
     fi
 }
 
+# Test creating a bad symlink and deleting it.
+test_bad_symlink()
+{
+    prompt="posix_unlink deleted file /newname"
+    tmpfile=/tmp/smbclient.in.$$
+
+    cat > $tmpfile <<EOF
+posix
+posix_unlink newname
+symlink badname newname
+posix_unlink newname
+quit
+EOF
+
+    cmd='CLI_FORCE_INTERACTIVE=yes $SMBCLIENT $CONFIGURATION "$@" -U$USERNAME%$PASSWORD //$SERVER/tmp -I $SERVER_IP $ADDARGS < $tmpfile 2>&1'
+    eval echo "$cmd"
+    out=`eval $cmd`
+    ret=$?
+    rm -f $tmpfile
+
+    if [ $ret != 0 ] ; then
+       echo "$out"
+       echo "failed create then delete bad symlink"
+       false
+       return
+    fi
+
+    echo "$out" | grep $prompt >/dev/null 2>&1
+
+    if [ $? = 0 ] ; then
+       # got the correct prompt .. succeed
+       true
+    else
+       echo "$out"
+       echo failed create then delete bad symlink
+       false
+    fi
+}
+
+
 testit "smbclient -L $SERVER_IP" $SMBCLIENT $CONFIGURATION -L $SERVER_IP -N -p 139 || failed=`expr $failed + 1`
 testit "smbclient -L $SERVER -I $SERVER_IP" $SMBCLIENT $CONFIGURATION -L $SERVER -I $SERVER_IP -N -p 139 || failed=`expr $failed + 1`
 
@@ -105,4 +145,8 @@ testit "interactive smbclient -l prompts on stdout" \
    test_interactive_prompt_stdout -l /tmp || \
     failed=`expr $failed + 1`
 
+testit "creating a bad symlink and deleting it" \
+   test_bad_symlink || \
+   failed=`expr $failed + 1`
+
 testok $0 $failed

diff --git a/source3/services/services_db.c b/source3/services/services_db.c
index 85ea1f8cd48e151dd56e2074421b70427f91c057..b610c922a9df2d7ed044997d2b835befef1bcfca 100644 (file)
--- a/source3/services/services_db.c
+++ b/source3/services/services_db.c
@@ -250,7 +250,7 @@ static bool read_init_file( const char *servicename, struct rcinit_file_informat
 
 static void fill_service_values(const char *name, struct regval_ctr *values)
 {
-       UNISTR2 data, dname, ipath, description;
+       char *dname, *ipath, *description;
        uint32 dword;
        int i;
 
@@ -268,24 +268,17 @@ static void fill_service_values(const char *name, struct regval_ctr *values)
 
        /* everything runs as LocalSystem */
 
-       init_unistr2( &data, "LocalSystem", UNI_STR_TERMINATE );
-       regval_ctr_addvalue( values, "ObjectName", REG_SZ, (char*)data.buffer, data.uni_str_len*2);
+       regval_ctr_addvalue_sz(values, "ObjectName", "LocalSystem");
 
        /* special considerations for internal services and the DisplayName value */
 
        for ( i=0; builtin_svcs[i].servicename; i++ ) {
                if ( strequal( name, builtin_svcs[i].servicename ) ) {
-                       char *pstr = NULL;
-                       if (asprintf(&pstr, "%s/%s/%s",
+                       ipath = talloc_asprintf(talloc_tos(), "%s/%s/%s",
                                        get_dyn_MODULESDIR(), SVCCTL_SCRIPT_DIR,
-                                       builtin_svcs[i].daemon) > 0) {
-                               init_unistr2( &ipath, pstr, UNI_STR_TERMINATE );
-                               SAFE_FREE(pstr);
-                       } else {
-                               init_unistr2( &ipath, "", UNI_STR_TERMINATE );
-                       }
-                       init_unistr2( &description, builtin_svcs[i].description, UNI_STR_TERMINATE );
-                       init_unistr2( &dname, builtin_svcs[i].dispname, UNI_STR_TERMINATE );
+                                       builtin_svcs[i].daemon);
+                       description = talloc_strdup(talloc_tos(), builtin_svcs[i].description);
+                       dname = talloc_strdup(talloc_tos(), builtin_svcs[i].dispname);
                        break;
                }
        }
@@ -293,38 +286,37 @@ static void fill_service_values(const char *name, struct regval_ctr *values)
        /* default to an external service if we haven't found a match */
 
        if ( builtin_svcs[i].servicename == NULL ) {
-               char *pstr = NULL;
                char *dispname = NULL;
                struct rcinit_file_information *init_info = NULL;
 
-               if (asprintf(&pstr, "%s/%s/%s",get_dyn_MODULESDIR(),
-                                       SVCCTL_SCRIPT_DIR, name) > 0) {
-                       init_unistr2( &ipath, pstr, UNI_STR_TERMINATE );
-                       SAFE_FREE(pstr);
-               } else {
-                       init_unistr2( &ipath, "", UNI_STR_TERMINATE );
-               }
+               ipath = talloc_asprintf(talloc_tos(), "%s/%s/%s",
+                                       get_dyn_MODULESDIR(), SVCCTL_SCRIPT_DIR,
+                                       name);
 
                /* lookup common unix display names */
                dispname = get_common_service_dispname(name);
-               init_unistr2( &dname, dispname ? dispname : "", UNI_STR_TERMINATE );
+               dname = talloc_strdup(talloc_tos(), dispname ? dispname : "");
                SAFE_FREE(dispname);
 
                /* get info from init file itself */
                if ( read_init_file( name, &init_info ) ) {
-                       init_unistr2( &description, init_info->description, UNI_STR_TERMINATE );
+                       description = talloc_strdup(talloc_tos(), init_info->description);
                        TALLOC_FREE( init_info );
                }
                else {
-                       init_unistr2( &description, "External Unix Service", UNI_STR_TERMINATE );
+                       description = talloc_strdup(talloc_tos(), "External Unix Service");
                }
        }
 
        /* add the new values */
 
-       regval_ctr_addvalue( values, "DisplayName", REG_SZ, (char*)dname.buffer, dname.uni_str_len*2);
-       regval_ctr_addvalue( values, "ImagePath", REG_SZ, (char*)ipath.buffer, ipath.uni_str_len*2);
-       regval_ctr_addvalue( values, "Description", REG_SZ, (char*)description.buffer, description.uni_str_len*2);
+       regval_ctr_addvalue_sz(values, "DisplayName", dname);
+       regval_ctr_addvalue_sz(values, "ImagePath", ipath);
+       regval_ctr_addvalue_sz(values, "Description", description);
+
+       TALLOC_FREE(dname);
+       TALLOC_FREE(ipath);
+       TALLOC_FREE(description);
 
        return;
 }
@@ -619,12 +611,13 @@ bool svcctl_set_secdesc( TALLOC_CTX *ctx, const char *name, SEC_DESC *sec_desc,
 
 const char *svcctl_lookup_dispname(TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
 {
-       char *display_name = NULL;
+       const char *display_name = NULL;
        struct registry_key_handle *key = NULL;
        struct regval_ctr *values = NULL;
        struct regval_blob *val = NULL;
        char *path = NULL;
        WERROR wresult;
+       DATA_BLOB blob;
 
        /* now add the security descriptor */
 
@@ -652,7 +645,8 @@ const char *svcctl_lookup_dispname(TALLOC_CTX *ctx, const char *name, NT_USER_TO
        if ( !(val = regval_ctr_getvalue( values, "DisplayName" )) )
                goto fail;
 
-       rpcstr_pull_talloc(ctx, &display_name, regval_data_p(val), regval_size(val), 0 );
+       blob = data_blob_const(regval_data_p(val), regval_size(val));
+       pull_reg_sz(ctx, &blob, &display_name);
 
        TALLOC_FREE( key );
 
@@ -669,12 +663,13 @@ fail:
 
 const char *svcctl_lookup_description(TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
 {
-       char *description = NULL;
+       const char *description = NULL;
        struct registry_key_handle *key = NULL;
        struct regval_ctr *values = NULL;
        struct regval_blob *val = NULL;
        char *path = NULL;
        WERROR wresult;
+       DATA_BLOB blob;
 
        /* now add the security descriptor */
 
@@ -703,7 +698,10 @@ const char *svcctl_lookup_description(TALLOC_CTX *ctx, const char *name, NT_USER
                TALLOC_FREE( key );
                return "Unix Service";
        }
-       rpcstr_pull_talloc(ctx, &description, regval_data_p(val), regval_size(val), 0 );
+
+       blob = data_blob_const(regval_data_p(val), regval_size(val));
+       pull_reg_sz(ctx, &blob, &description);
+
        TALLOC_FREE(key);
 
        return description;

diff --git a/source3/smbd/aio.c b/source3/smbd/aio.c
index c0367a5ee813ab57d78176b0cfd582dbd29d027d..751fed168f2967cd246d60f14c045338a5b77430 100644 (file)
--- a/source3/smbd/aio.c
+++ b/source3/smbd/aio.c
@@ -45,11 +45,11 @@ struct aio_extra {
        files_struct *fsp;
        struct smb_request *req;
        char *outbuf;
-       int (*handle_completion)(struct aio_extra *ex);
+       int (*handle_completion)(struct aio_extra *ex, int errcode);
 };
 
-static int handle_aio_read_complete(struct aio_extra *aio_ex);
-static int handle_aio_write_complete(struct aio_extra *aio_ex);
+static int handle_aio_read_complete(struct aio_extra *aio_ex, int errcode);
+static int handle_aio_write_complete(struct aio_extra *aio_ex, int errcode);
 
 static int aio_extra_destructor(struct aio_extra *aio_ex)
 {
@@ -184,6 +184,7 @@ bool schedule_aio_read_and_X(connection_struct *conn,
                return False;
        }
 
+       outstanding_aio_calls++;
        aio_ex->req = talloc_move(aio_ex, &req);
 
        DEBUG(10,("schedule_aio_read_and_X: scheduled aio_read for file %s, "
@@ -191,7 +192,6 @@ bool schedule_aio_read_and_X(connection_struct *conn,
                  fsp_str_dbg(fsp), (double)startpos, (unsigned int)smb_maxcnt,
                  (unsigned int)aio_ex->req->mid ));
 
-       outstanding_aio_calls++;
        return True;
 }
 
@@ -279,6 +279,7 @@ bool schedule_aio_write_and_X(connection_struct *conn,
                return False;
        }
 
+       outstanding_aio_calls++;
        aio_ex->req = talloc_move(aio_ex, &req);
 
        /* This should actually be improved to span the write. */
@@ -302,7 +303,6 @@ bool schedule_aio_write_and_X(connection_struct *conn,
                DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write "
                          "behind for file %s\n", fsp_str_dbg(fsp)));
        }
-       outstanding_aio_calls++;
 
        DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write for file "
                  "%s, offset %.0f, len = %u (mid = %u) "
@@ -319,9 +319,8 @@ bool schedule_aio_write_and_X(connection_struct *conn,
  Returns errno or zero if all ok.
 *****************************************************************************/
 
-static int handle_aio_read_complete(struct aio_extra *aio_ex)
+static int handle_aio_read_complete(struct aio_extra *aio_ex, int errcode)
 {
-       int ret = 0;
        int outsize;
        char *outbuf = aio_ex->outbuf;
        char *data = smb_buf(outbuf);
@@ -333,18 +332,11 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
                   will return an error. Hopefully this is
                   true.... JRA. */
 
-               /* If errno is ECANCELED then don't return anything to the
-                * client. */
-               if (errno == ECANCELED) {
-                       return 0;
-               }
-
-               DEBUG( 3,( "handle_aio_read_complete: file %s nread == -1. "
+               DEBUG( 3,( "handle_aio_read_complete: file %s nread == %d. "
                           "Error = %s\n",
-                          fsp_str_dbg(aio_ex->fsp), strerror(errno)));
+                          fsp_str_dbg(aio_ex->fsp), (int)nread, strerror(errcode)));
 
-               ret = errno;
-               ERROR_NT(map_nt_error_from_unix(ret));
+               ERROR_NT(map_nt_error_from_unix(errcode));
                outsize = srv_set_message(outbuf,0,0,true);
        } else {
                outsize = srv_set_message(outbuf,12,nread,False);
@@ -377,17 +369,16 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
                  fsp_str_dbg(aio_ex->fsp), (double)aio_ex->acb.aio_offset,
                  (unsigned int)nread ));
 
-       return ret;
+       return errcode;
 }
 
 /****************************************************************************
  Complete the write and return the data or error back to the client.
- Returns errno or zero if all ok.
+ Returns error code or zero if all ok.
 *****************************************************************************/
 
-static int handle_aio_write_complete(struct aio_extra *aio_ex)
+static int handle_aio_write_complete(struct aio_extra *aio_ex, int errcode)
 {
-       int ret = 0;
        files_struct *fsp = aio_ex->fsp;
        char *outbuf = aio_ex->outbuf;
        ssize_t numtowrite = aio_ex->acb.aio_nbytes;
@@ -399,8 +390,7 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
                                DEBUG(5,("handle_aio_write_complete: "
                                         "aio_write_behind failed ! File %s "
                                         "is corrupt ! Error %s\n",
-                                        fsp_str_dbg(fsp), strerror(errno)));
-                               ret = errno;
+                                        fsp_str_dbg(fsp), strerror(errcode)));
                        } else {
                                DEBUG(0,("handle_aio_write_complete: "
                                         "aio_write_behind failed ! File %s "
@@ -408,13 +398,14 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
                                         "only wrote %d\n", fsp_str_dbg(fsp),
                                         (unsigned int)numtowrite,
                                         (int)nwritten ));
-                               ret = EIO;
+                               errcode = EIO;
                        }
                } else {
                        DEBUG(10,("handle_aio_write_complete: "
                                  "aio_write_behind completed for file %s\n",
                                  fsp_str_dbg(fsp)));
                }
+               /* TODO: should no return 0 in case of an error !!! */
                return 0;
        }
 
@@ -425,16 +416,9 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
                DEBUG( 3,( "handle_aio_write: file %s wanted %u bytes. "
                           "nwritten == %d. Error = %s\n",
                           fsp_str_dbg(fsp), (unsigned int)numtowrite,
-                          (int)nwritten, strerror(errno) ));
+                          (int)nwritten, strerror(errcode) ));
 
-               /* If errno is ECANCELED then don't return anything to the
-                * client. */
-               if (errno == ECANCELED) {
-                       return 0;
-               }
-
-               ret = errno;
-               ERROR_BOTH(map_nt_error_from_unix(ret), ERRHRD, ERRdiskfull);
+               ERROR_NT(map_nt_error_from_unix(errcode));
                srv_set_message(outbuf,0,0,true);
         } else {
                bool write_through = BITSETW(aio_ex->req->vwv+7,0);
@@ -451,8 +435,8 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
                         fsp->fnum, (int)numtowrite, (int)nwritten));
                status = sync_file(fsp->conn,fsp, write_through);
                if (!NT_STATUS_IS_OK(status)) {
-                       ret = errno;
-                       ERROR_BOTH(map_nt_error_from_unix(ret),
+                       errcode = errno;
+                       ERROR_BOTH(map_nt_error_from_unix(errcode),
                                   ERRHRD, ERRdiskfull);
                        srv_set_message(outbuf,0,0,true);
                        DEBUG(5,("handle_aio_write: sync_file for %s returned %s\n",
@@ -475,7 +459,7 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
                  fsp_str_dbg(fsp), (double)aio_ex->acb.aio_offset,
                  (unsigned int)numtowrite, (unsigned int)nwritten ));
 
-       return ret;
+       return errcode;
 }
 
 /****************************************************************************
@@ -493,14 +477,21 @@ static bool handle_aio_completed(struct aio_extra *aio_ex, int *perr)
        }
 
        /* Ensure the operation has really completed. */
-       if (SMB_VFS_AIO_ERROR(aio_ex->fsp, &aio_ex->acb) == EINPROGRESS) {
+       err = SMB_VFS_AIO_ERROR(aio_ex->fsp, &aio_ex->acb);
+       if (err == EINPROGRESS) {
                DEBUG(10,( "handle_aio_completed: operation mid %u still in "
                           "process for file %s\n",
                           aio_ex->req->mid, fsp_str_dbg(aio_ex->fsp)));
                return False;
-       }
+       } else if (err == ECANCELED) {
+               /* If error is ECANCELED then don't return anything to the
+                * client. */
+               DEBUG(10,( "handle_aio_completed: operation mid %u"
+                           " canceled\n", aio_ex->req->mid));
+               return True;
+        }
 
-       err = aio_ex->handle_completion(aio_ex);
+       err = aio_ex->handle_completion(aio_ex, err);
        if (err) {
                *perr = err; /* Only save non-zero errors. */
        }
@@ -510,7 +501,6 @@ static bool handle_aio_completed(struct aio_extra *aio_ex, int *perr)
 
 /****************************************************************************
  Handle any aio completion inline.
- Returns non-zero errno if fail or zero if all ok.
 *****************************************************************************/
 
 void smbd_aio_complete_mid(unsigned int mid)
@@ -519,6 +509,8 @@ void smbd_aio_complete_mid(unsigned int mid)
        struct aio_extra *aio_ex = find_aio_ex(mid);
        int ret = 0;
 
+       outstanding_aio_calls--;
+
        DEBUG(10,("smbd_aio_complete_mid: mid[%u]\n", mid));
 
        if (!aio_ex) {

diff --git a/source3/smbd/chgpasswd.c b/source3/smbd/chgpasswd.c
index eaee3d8509d3c61eb1236b20a264607afd95511c..e2069060aade545b35ae28473e4b83702c203e71 100644 (file)
--- a/source3/smbd/chgpasswd.c
+++ b/source3/smbd/chgpasswd.c
@@ -778,7 +778,7 @@ NTSTATUS pass_oem_change(char *user,
                         const uchar old_lm_hash_encrypted[16],
                         uchar password_encrypted_with_nt_hash[516],
                         const uchar old_nt_hash_encrypted[16],
-                        uint32 *reject_reason)
+                        enum samPwdChangeReason *reject_reason)
 {
        char *new_passwd = NULL;
        struct samu *sampass = NULL;
@@ -1081,7 +1081,7 @@ static bool check_passwd_history(struct samu *sampass, const char *plaintext)
  is correct before calling. JRA.
 ************************************************************/
 
-NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passwd, bool as_root, uint32 *samr_reject_reason)
+NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passwd, bool as_root, enum samPwdChangeReason *samr_reject_reason)
 {
        uint32 min_len;
        uint32 refuse;
@@ -1091,14 +1091,14 @@ NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passw
        time_t can_change_time = pdb_get_pass_can_change_time(hnd);
 
        if (samr_reject_reason) {
-               *samr_reject_reason = Undefined;
+               *samr_reject_reason = SAM_PWD_CHANGE_NO_ERROR;
        }
 
        /* check to see if the secdesc has previously been set to disallow */
        if (!pdb_get_pass_can_change(hnd)) {
                DEBUG(1, ("user %s does not have permissions to change password\n", username));
                if (samr_reject_reason) {
-                       *samr_reject_reason = SAMR_REJECT_OTHER;
+                       *samr_reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                }
                return NT_STATUS_ACCOUNT_RESTRICTION;
        }
@@ -1112,7 +1112,7 @@ NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passw
                                  "denied by Refuse Machine Password Change policy\n",
                                  username));
                        if (samr_reject_reason) {
-                               *samr_reject_reason = SAMR_REJECT_OTHER;
+                               *samr_reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                        }
                        return NT_STATUS_ACCOUNT_RESTRICTION;
                }
@@ -1125,7 +1125,7 @@ NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passw
                          "wait until %s\n", username,
                          http_timestring(tosctx, can_change_time)));
                if (samr_reject_reason) {
-                       *samr_reject_reason = SAMR_REJECT_OTHER;
+                       *samr_reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                }
                return NT_STATUS_ACCOUNT_RESTRICTION;
        }
@@ -1135,7 +1135,7 @@ NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passw
                          username));
                DEBUGADD(1, (" account policy min password len = %d\n", min_len));
                if (samr_reject_reason) {
-                       *samr_reject_reason = SAMR_REJECT_TOO_SHORT;
+                       *samr_reject_reason = SAM_PWD_CHANGE_PASSWORD_TOO_SHORT;
                }
                return NT_STATUS_PASSWORD_RESTRICTION;
 /*             return NT_STATUS_PWD_TOO_SHORT; */
@@ -1143,7 +1143,7 @@ NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passw
 
        if (check_passwd_history(hnd,new_passwd)) {
                if (samr_reject_reason) {
-                       *samr_reject_reason = SAMR_REJECT_IN_HISTORY;
+                       *samr_reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
                }
                return NT_STATUS_PASSWORD_RESTRICTION;
        }
@@ -1171,7 +1171,7 @@ NTSTATUS change_oem_password(struct samu *hnd, char *old_passwd, char *new_passw
                if (check_ret != 0) {
                        DEBUG(1, ("change_oem_password: check password script said new password is not good enough!\n"));
                        if (samr_reject_reason) {
-                               *samr_reject_reason = SAMR_REJECT_COMPLEXITY;
+                               *samr_reject_reason = SAM_PWD_CHANGE_NOT_COMPLEX;
                        }
                        TALLOC_FREE(pass);
                        return NT_STATUS_PASSWORD_RESTRICTION;

diff --git a/source3/smbd/close.c b/source3/smbd/close.c
index 1f2e4604c228f23722a0707b27ebbf872e1bf668..642864f27e81ae40546c7f99cc6ffa9446674224 100644 (file)
--- a/source3/smbd/close.c
+++ b/source3/smbd/close.c
@@ -271,7 +271,7 @@ static NTSTATUS close_remove_share_mode(files_struct *fsp,
        bool changed_user = false;
        struct share_mode_lock *lck = NULL;
        NTSTATUS status = NT_STATUS_OK;
-       int ret;
+       NTSTATUS tmp_status;
        struct file_id id;
 
        /*
@@ -387,16 +387,11 @@ static NTSTATUS close_remove_share_mode(files_struct *fsp,
        /* We can only delete the file if the name we have is still valid and
           hasn't been renamed. */
 
-       if (fsp->posix_open) {
-               ret = SMB_VFS_LSTAT(conn, fsp->fsp_name);
-       } else {
-               ret = SMB_VFS_STAT(conn, fsp->fsp_name);
-       }
-
-       if (ret != 0) {
+       tmp_status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(tmp_status)) {
                DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
                         "was set and stat failed with error %s\n",
-                        fsp_str_dbg(fsp), strerror(errno)));
+                        fsp_str_dbg(fsp), nt_errstr(tmp_status)));
                /*
                 * Don't save the errno here, we ignore this error
                 */
@@ -494,7 +489,6 @@ static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
 {
        struct smb_file_time ft;
        NTSTATUS status;
-       int ret = -1;
 
        ZERO_STRUCT(ft);
 
@@ -507,18 +501,9 @@ static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
        }
 
        /* Ensure we have a valid stat struct for the source. */
-       if (fsp->fh->fd != -1) {
-               ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
-       } else {
-               if (fsp->posix_open) {
-                       ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
-               } else {
-                       ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
-               }
-       }
-
-       if (ret == -1) {
-               return map_nt_error_from_unix(errno);
+       status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
        }
 
        if (!VALID_STAT(fsp->fsp_name->st)) {

diff --git a/source3/smbd/files.c b/source3/smbd/files.c
index 146d80973874101742dd6c25f373fdd36a479fd0..2bc5ba6816e0a75ed431c6239652c765364ab654 100644 (file)
--- a/source3/smbd/files.c
+++ b/source3/smbd/files.c
@@ -405,14 +405,13 @@ bool file_find_subpath(files_struct *dir_fsp)
        files_struct *fsp;
        size_t dlen;
        char *d_fullname = NULL;
-       bool ret = false;
 
        d_fullname = talloc_asprintf(talloc_tos(), "%s/%s",
                                     dir_fsp->conn->connectpath,
                                     dir_fsp->fsp_name->base_name);
 
        if (!d_fullname) {
-               goto out;
+               return false;
        }
 
        dlen = strlen(d_fullname);
@@ -429,28 +428,21 @@ bool file_find_subpath(files_struct *dir_fsp)
                                        fsp->conn->connectpath,
                                        fsp->fsp_name->base_name);
 
-               if (strnequal(d_fullname, d1_fullname, dlen)) {
-                       int d1_len = strlen(d1_fullname);
-
-                       /*
-                        * If the open file is a second file handle to the
-                        * same name or is a stream on the original file, then
-                        * don't return true.
-                        */
-                       if (d1_len == dlen) {
-                               TALLOC_FREE(d1_fullname);
-                               continue;
-                       }
-
+               /*
+                * If the open file has a path that is a longer
+                * component, then it's a subpath.
+                */
+               if (strnequal(d_fullname, d1_fullname, dlen) &&
+                               (d1_fullname[dlen] == '/')) {
                        TALLOC_FREE(d1_fullname);
-                       ret = true;
-                       goto out;
+                       TALLOC_FREE(d_fullname);
+                       return true;
                }
                TALLOC_FREE(d1_fullname);
-       } 
- out:
+       }
+
        TALLOC_FREE(d_fullname);
-       return ret;
+       return false;
 }
 
 /****************************************************************************

diff --git a/source3/smbd/nttrans.c b/source3/smbd/nttrans.c
index cf955d9651d8585f32938c2daf86b4f88b63581c..0cc05dbd52ef17ebf19c14f1f8506802aad528ea 100644 (file)
--- a/source3/smbd/nttrans.c
+++ b/source3/smbd/nttrans.c
@@ -2036,7 +2036,7 @@ static void call_nt_transact_ioctl(connection_struct *conn,
                }
 
                /* needed_data_count 4 bytes */
-               SIVAL(pdata,8,labels_data_count);
+               SIVAL(pdata, 8, labels_data_count+4);
 
                cur_pdata+=12;
 

diff --git a/source3/smbd/open.c b/source3/smbd/open.c
index 492164ceeee50af7e56143c51b53d7327553d43c..85b7d9106ddd37ad8c067aa6d0d1aa9ec230b49b 100644 (file)
--- a/source3/smbd/open.c
+++ b/source3/smbd/open.c
@@ -2091,7 +2091,7 @@ static NTSTATUS open_file_ntcreate(connection_struct *conn,
           note that GPFS supports it as well - jmcd */
 
        if (fsp->fh->fd != -1) {
-               ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access);
+               ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
                if(ret_flock == -1 ){
 
                        TALLOC_FREE(lck);

diff --git a/source3/smbd/posix_acls.c b/source3/smbd/posix_acls.c
index b61421dc8f6975b26915f3093d6a5540b8b7b8b0..32a04c51e4ef7b02c77829925a7ae7b75d104e8e 100644 (file)
--- a/source3/smbd/posix_acls.c
+++ b/source3/smbd/posix_acls.c
@@ -3377,6 +3377,7 @@ NTSTATUS posix_get_nt_acl(struct connection_struct *conn, const char *name,
        struct pai_val *pal;
        struct smb_filename *smb_fname = NULL;
        NTSTATUS status;
+       int ret;
 
        *ppdesc = NULL;
 
@@ -3389,7 +3390,13 @@ NTSTATUS posix_get_nt_acl(struct connection_struct *conn, const char *name,
        }
 
        /* Get the stat struct for the owner info. */
-       if(SMB_VFS_STAT(conn, smb_fname) != 0) {
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LSTAT(conn, smb_fname);
+       } else {
+               ret = SMB_VFS_STAT(conn, smb_fname);
+       }
+
+       if (ret == -1) {
                status = map_nt_error_from_unix(errno);
                goto out;
        }
@@ -3435,7 +3442,12 @@ int try_chown(connection_struct *conn, struct smb_filename *smb_fname,
 
        /* Case (1). */
        /* try the direct way first */
-       ret = SMB_VFS_CHOWN(conn, smb_fname->base_name, uid, gid);
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name, uid, gid);
+       } else {
+               ret = SMB_VFS_CHOWN(conn, smb_fname->base_name, uid, gid);
+       }
+
        if (ret == 0)
                return 0;
 
@@ -3454,8 +3466,13 @@ int try_chown(connection_struct *conn, struct smb_filename *smb_fname,
 
                        become_root();
                        /* Keep the current file gid the same - take ownership doesn't imply group change. */
-                       ret = SMB_VFS_CHOWN(conn, smb_fname->base_name, uid,
-                                           (gid_t)-1);
+                       if (lp_posix_pathnames()) {
+                               ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name, uid,
+                                                   (gid_t)-1);
+                       } else {
+                               ret = SMB_VFS_CHOWN(conn, smb_fname->base_name, uid,
+                                                   (gid_t)-1);
+                       }
                        unbecome_root();
                        return ret;
                }
@@ -3476,7 +3493,13 @@ int try_chown(connection_struct *conn, struct smb_filename *smb_fname,
                return -1;
        }
 
-       if (SMB_VFS_STAT(conn, smb_fname)) {
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LSTAT(conn, smb_fname);
+       } else {
+               ret = SMB_VFS_STAT(conn, smb_fname);
+       }
+
+       if (ret == -1) {
                return -1;
        }
 
@@ -3729,14 +3752,9 @@ NTSTATUS set_nt_acl(files_struct *fsp, uint32 security_info_sent, const SEC_DESC
         * Get the current state of the file.
         */
 
-       if(fsp->is_directory || fsp->fh->fd == -1) {
-               if(SMB_VFS_STAT(fsp->conn, fsp->fsp_name) != 0) {
-                       return map_nt_error_from_unix(errno);
-               }
-       } else {
-               if(SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
-                       return map_nt_error_from_unix(errno);
-               }
+       status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
        }
 
        /* Save the original element we check against. */
@@ -3780,21 +3798,9 @@ NTSTATUS set_nt_acl(files_struct *fsp, uint32 security_info_sent, const SEC_DESC
                 * (suid/sgid bits, for instance)
                 */
 
-               if(fsp->is_directory) {
-                       if(SMB_VFS_STAT(fsp->conn, fsp->fsp_name) != 0) {
-                               return map_nt_error_from_unix(errno);
-                       }
-               } else {
-
-                       int sret;
-
-                       if(fsp->fh->fd == -1)
-                               sret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
-                       else
-                               sret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
-
-                       if(sret != 0)
-                               return map_nt_error_from_unix(errno);
+               status = vfs_stat_fsp(fsp);
+               if (!NT_STATUS_IS_OK(status)) {
+                       return status;
                }
 
                /* Save the original element we check against. */

diff --git a/source3/smbd/process.c b/source3/smbd/process.c
index ccb7f9dce3e25013c22b763473fabe5447a81708..fbaa9dee290491016be52e8f0d6d805da8e09355 100644 (file)
--- a/source3/smbd/process.c
+++ b/source3/smbd/process.c
@@ -417,6 +417,7 @@ static void smbd_deferred_open_timer(struct event_context *ev,
        struct pending_message_list *msg = talloc_get_type(private_data,
                                           struct pending_message_list);
        TALLOC_CTX *mem_ctx = talloc_tos();
+       uint16_t mid = SVAL(msg->buf.data,smb_mid);
        uint8_t *inbuf;
 
        inbuf = (uint8_t *)talloc_memdup(mem_ctx, msg->buf.data,
@@ -429,11 +430,21 @@ static void smbd_deferred_open_timer(struct event_context *ev,
        /* We leave this message on the queue so the open code can
           know this is a retry. */
        DEBUG(5,("smbd_deferred_open_timer: trigger mid %u.\n",
-               (unsigned int)SVAL(msg->buf.data,smb_mid)));
+               (unsigned int)mid ));
+
+       /* Mark the message as processed so this is not
+        * re-processed in error. */
+       msg->processed = true;
 
        process_smb(smbd_server_conn, inbuf,
                    msg->buf.length, 0,
                    msg->seqnum, msg->encrypted, &msg->pcd);
+
+       /* If it's still there and was processed, remove it. */
+       msg = get_open_deferred_message(mid);
+       if (msg && msg->processed) {
+               remove_deferred_open_smb_message(mid);
+       }
 }
 
 /****************************************************************************
@@ -466,6 +477,7 @@ static bool push_queued_message(struct smb_request *req,
        msg->request_time = request_time;
        msg->seqnum = req->seqnum;
        msg->encrypted = req->encrypted;
+       msg->processed = false;
        SMB_PERFCOUNT_DEFER_OP(&req->pcd, &msg->pcd);
 
        if (private_data) {
@@ -507,7 +519,7 @@ void remove_deferred_open_smb_message(uint16 mid)
 
        for (pml = deferred_open_queue; pml; pml = pml->next) {
                if (mid == SVAL(pml->buf.data,smb_mid)) {
-                       DEBUG(10,("remove_sharing_violation_open_smb_message: "
+                       DEBUG(10,("remove_deferred_open_smb_message: "
                                  "deleting mid %u len %u\n",
                                  (unsigned int)mid,
                                  (unsigned int)pml->buf.length ));
@@ -537,6 +549,15 @@ void schedule_deferred_open_smb_message(uint16 mid)
                if (mid == msg_mid) {
                        struct timed_event *te;
 
+                       if (pml->processed) {
+                               /* A processed message should not be
+                                * rescheduled. */
+                               DEBUG(0,("schedule_deferred_open_smb_message: LOGIC ERROR "
+                                       "message mid %u was already processed\n",
+                                       msg_mid ));
+                               continue;
+                       }
+
                        DEBUG(10,("schedule_deferred_open_smb_message: scheduling mid %u\n",
                                mid ));
 
@@ -563,7 +584,7 @@ void schedule_deferred_open_smb_message(uint16 mid)
 }
 
 /****************************************************************************
- Return true if this mid is on the deferred queue.
+ Return true if this mid is on the deferred queue and was not yet processed.
 ****************************************************************************/
 
 bool open_was_deferred(uint16 mid)
@@ -571,7 +592,7 @@ bool open_was_deferred(uint16 mid)
        struct pending_message_list *pml;
 
        for (pml = deferred_open_queue; pml; pml = pml->next) {
-               if (SVAL(pml->buf.data,smb_mid) == mid) {
+               if (SVAL(pml->buf.data,smb_mid) == mid && !pml->processed) {
                        return True;
                }
        }
@@ -1309,7 +1330,6 @@ static connection_struct *switch_message(uint8 type, struct smb_request *req, in
                        DEBUG(0, ("Error: Could not change to user. Removing "
                            "deferred open, mid=%d.\n", req->mid));
                        reply_nterror(req, NT_STATUS_DOS(ERRSRV, ERRbaduid));
-                       remove_deferred_open_smb_message(req->mid);
                        return conn;
                }
 

diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c
index a3280cb9d4ae36910098cdbae9cdce41bfc09588..2365ed1da1446daf7f0ff185f6d84ab55760d66e 100644 (file)
--- a/source3/smbd/reply.c
+++ b/source3/smbd/reply.c
@@ -2383,6 +2383,8 @@ static NTSTATUS do_unlink(connection_struct *conn,
        files_struct *fsp;
        uint32 dirtype_orig = dirtype;
        NTSTATUS status;
+       int ret;
+       bool posix_paths = lp_posix_pathnames();
 
        DEBUG(10,("do_unlink: %s, dirtype = %d\n",
                  smb_fname_str_dbg(smb_fname),
@@ -2392,7 +2394,12 @@ static NTSTATUS do_unlink(connection_struct *conn,
                return NT_STATUS_MEDIA_WRITE_PROTECTED;
        }
 
-       if (SMB_VFS_LSTAT(conn, smb_fname) != 0) {
+       if (posix_paths) {
+               ret = SMB_VFS_LSTAT(conn, smb_fname);
+       } else {
+               ret = SMB_VFS_LSTAT(conn, smb_fname);
+       }
+       if (ret != 0) {
                return map_nt_error_from_unix(errno);
        }
 
@@ -2479,7 +2486,9 @@ static NTSTATUS do_unlink(connection_struct *conn,
                 FILE_SHARE_NONE,       /* share_access */
                 FILE_OPEN,             /* create_disposition*/
                 FILE_NON_DIRECTORY_FILE, /* create_options */
-                FILE_ATTRIBUTE_NORMAL, /* file_attributes */
+                                       /* file_attributes */
+                posix_paths ? FILE_FLAG_POSIX_SEMANTICS|0777 :
+                               FILE_ATTRIBUTE_NORMAL,
                 0,                     /* oplock_request */
                 0,                     /* allocation_size */
                 NULL,                  /* sd */
@@ -5860,25 +5869,17 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
                        bool replace_if_exists)
 {
        TALLOC_CTX *ctx = talloc_tos();
-       struct smb_filename *smb_fname_src = NULL;
        struct smb_filename *smb_fname_dst = NULL;
-       SMB_STRUCT_STAT sbuf;
        NTSTATUS status = NT_STATUS_OK;
        struct share_mode_lock *lck = NULL;
        bool dst_exists, old_is_stream, new_is_stream;
 
-       ZERO_STRUCT(sbuf);
-
        status = check_name(conn, smb_fname_dst_in->base_name);
        if (!NT_STATUS_IS_OK(status)) {
                return status;
        }
 
-       /* Make a copy of the src and dst smb_fname structs */
-       status = copy_smb_filename(ctx, fsp->fsp_name, &smb_fname_src);
-       if (!NT_STATUS_IS_OK(status)) {
-               goto out;
-       }
+       /* Make a copy of the dst smb_fname structs */
 
        status = copy_smb_filename(ctx, smb_fname_dst_in, &smb_fname_dst);
        if (!NT_STATUS_IS_OK(status)) {
@@ -5906,8 +5907,8 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
         * filename).
         */
        if((conn->case_sensitive == False) && (conn->case_preserve == True) &&
-           strequal(smb_fname_src->base_name, smb_fname_dst->base_name) &&
-           strequal(smb_fname_src->stream_name, smb_fname_dst->stream_name)) {
+           strequal(fsp->fsp_name->base_name, smb_fname_dst->base_name) &&
+           strequal(fsp->fsp_name->stream_name, smb_fname_dst->stream_name)) {
                char *last_slash;
                char *fname_dst_lcomp_base_mod = NULL;
                struct smb_filename *smb_fname_orig_lcomp = NULL;
@@ -5984,8 +5985,8 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
         * don't do the rename, just return success.
         */
 
-       if (strcsequal(smb_fname_src->base_name, smb_fname_dst->base_name) &&
-           strcsequal(smb_fname_src->stream_name,
+       if (strcsequal(fsp->fsp_name->base_name, smb_fname_dst->base_name) &&
+           strcsequal(fsp->fsp_name->stream_name,
                       smb_fname_dst->stream_name)) {
                DEBUG(3, ("rename_internals_fsp: identical names in rename %s "
                          "- returning success\n",
@@ -5994,7 +5995,7 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
                goto out;
        }
 
-       old_is_stream = is_ntfs_stream_smb_fname(smb_fname_src);
+       old_is_stream = is_ntfs_stream_smb_fname(fsp->fsp_name);
        new_is_stream = is_ntfs_stream_smb_fname(smb_fname_dst);
 
        /* Return the correct error code if both names aren't streams. */
@@ -6012,7 +6013,7 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
 
        if(!replace_if_exists && dst_exists) {
                DEBUG(3, ("rename_internals_fsp: dest exists doing rename "
-                         "%s -> %s\n", smb_fname_str_dbg(smb_fname_src),
+                         "%s -> %s\n", smb_fname_str_dbg(fsp->fsp_name),
                          smb_fname_str_dbg(smb_fname_dst)));
                status = NT_STATUS_OBJECT_NAME_COLLISION;
                goto out;
@@ -6031,38 +6032,23 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
        }
 
        /* Ensure we have a valid stat struct for the source. */
-       if (fsp->fh->fd != -1) {
-               if (SMB_VFS_FSTAT(fsp, &sbuf) == -1) {
-                       status = map_nt_error_from_unix(errno);
-                       goto out;
-               }
-       } else {
-               int ret = -1;
-               if (fsp->posix_open) {
-                       ret = SMB_VFS_LSTAT(conn, smb_fname_src);
-               } else {
-
-                       ret = SMB_VFS_STAT(conn, smb_fname_src);
-               }
-               if (ret == -1) {
-                       status = map_nt_error_from_unix(errno);
-                       goto out;
-               }
-               sbuf = smb_fname_src->st;
+       status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(status)) {
+               goto out;
        }
 
-       status = can_rename(conn, fsp, attrs, &sbuf);
+       status = can_rename(conn, fsp, attrs, &fsp->fsp_name->st);
 
        if (!NT_STATUS_IS_OK(status)) {
                DEBUG(3, ("rename_internals_fsp: Error %s rename %s -> %s\n",
-                         nt_errstr(status), smb_fname_str_dbg(smb_fname_src),
+                         nt_errstr(status), smb_fname_str_dbg(fsp->fsp_name),
                          smb_fname_str_dbg(smb_fname_dst)));
                if (NT_STATUS_EQUAL(status,NT_STATUS_SHARING_VIOLATION))
                        status = NT_STATUS_ACCESS_DENIED;
                goto out;
        }
 
-       if (rename_path_prefix_equal(smb_fname_src, smb_fname_dst)) {
+       if (rename_path_prefix_equal(fsp->fsp_name, smb_fname_dst)) {
                status = NT_STATUS_ACCESS_DENIED;
        }
 
@@ -6076,14 +6062,14 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
 
        SMB_ASSERT(lck != NULL);
 
-       if(SMB_VFS_RENAME(conn, smb_fname_src, smb_fname_dst) == 0) {
+       if(SMB_VFS_RENAME(conn, fsp->fsp_name, smb_fname_dst) == 0) {
                uint32 create_options = fsp->fh->private_options;
 
                DEBUG(3, ("rename_internals_fsp: succeeded doing rename on "
-                         "%s -> %s\n", smb_fname_str_dbg(smb_fname_src),
+                         "%s -> %s\n", smb_fname_str_dbg(fsp->fsp_name),
                          smb_fname_str_dbg(smb_fname_dst)));
 
-               notify_rename(conn, fsp->is_directory, smb_fname_src,
+               notify_rename(conn, fsp->is_directory, fsp->fsp_name,
                              smb_fname_dst);
 
                rename_open_files(conn, lck, smb_fname_dst);
@@ -6120,11 +6106,10 @@ NTSTATUS rename_internals_fsp(connection_struct *conn,
        }
 
        DEBUG(3, ("rename_internals_fsp: Error %s rename %s -> %s\n",
-                 nt_errstr(status), smb_fname_str_dbg(smb_fname_src),
+                 nt_errstr(status), smb_fname_str_dbg(fsp->fsp_name),
                  smb_fname_str_dbg(smb_fname_dst)));
 
  out:
-       TALLOC_FREE(smb_fname_src);
        TALLOC_FREE(smb_fname_dst);
 
        return status;
@@ -7707,25 +7692,10 @@ void reply_setattrE(struct smb_request *req)
         */
 
        /* Ensure we have a valid stat struct for the source. */
-       if (fsp->fh->fd != -1) {
-               if (SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) == -1) {
-                       status = map_nt_error_from_unix(errno);
-                       reply_nterror(req, status);
-                       goto out;
-               }
-       } else {
-               int ret = -1;
-
-               if (fsp->posix_open) {
-                       ret = SMB_VFS_LSTAT(conn, fsp->fsp_name);
-               } else {
-                       ret = SMB_VFS_STAT(conn, fsp->fsp_name);
-               }
-               if (ret == -1) {
-                       status = map_nt_error_from_unix(errno);
-                       reply_nterror(req, status);
-                       goto out;
-               }
+       status = vfs_stat_fsp(fsp);
+       if (!NT_STATUS_IS_OK(status)) {
+               reply_nterror(req, status);
+               goto out;
        }
 
        status = smb_set_file_time(conn, fsp, fsp->fsp_name, &ft, true);

diff --git a/source3/smbd/service.c b/source3/smbd/service.c
index 3520f0d411becbf0bef70ecaf939613f097ee7c9..b5946f0335cf384f95bfd5120153c8821a2c09e7 100644 (file)
--- a/source3/smbd/service.c
+++ b/source3/smbd/service.c
@@ -56,6 +56,10 @@ bool set_conn_connectpath(connection_struct *conn, const char *connectpath)
        const char *s = connectpath;
         bool start_of_name_component = true;
 
+       if (connectpath == NULL || connectpath[0] == '\0') {
+               return false;
+       }
+
        destname = SMB_STRDUP(connectpath);
        if (!destname) {
                return false;
@@ -259,7 +263,7 @@ int add_home_service(const char *service, const char *username, const char *home
 {
        int iHomeService;
 
-       if (!service || !homedir)
+       if (!service || !homedir || homedir[0] == '\0')
                return -1;
 
        if ((iHomeService = lp_servicenumber(HOMES_NAME)) < 0) {

diff --git a/source3/smbd/vfs.c b/source3/smbd/vfs.c
index 9b2df42c5841b286e68f254e04d42ab3b48a7bb1..35e4f3f9868466e8c9894ba05e65809cd891d498 100644 (file)
--- a/source3/smbd/vfs.c
+++ b/source3/smbd/vfs.c
@@ -1008,7 +1008,12 @@ int vfs_stat_smb_fname(struct connection_struct *conn, const char *fname,
                return -1;
        }
 
-       ret = SMB_VFS_STAT(conn, smb_fname);
+       if (lp_posix_pathnames()) {
+               ret = SMB_VFS_LSTAT(conn, smb_fname);
+       } else {
+               ret = SMB_VFS_STAT(conn, smb_fname);
+       }
+
        if (ret != -1) {
                *psbuf = smb_fname->st;
        }
@@ -1044,6 +1049,31 @@ int vfs_lstat_smb_fname(struct connection_struct *conn, const char *fname,
        return ret;
 }
 
+/**
+ * Ensure LSTAT is called for POSIX paths.
+ */
+
+NTSTATUS vfs_stat_fsp(files_struct *fsp)
+{
+       int ret;
+
+       if(fsp->is_directory || fsp->fh->fd == -1) {
+               if (fsp->posix_open) {
+                       ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
+               } else {
+                       ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
+               }
+               if (ret == -1) {
+                       return map_nt_error_from_unix(errno);
+               }
+       } else {
+               if(SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
+                       return map_nt_error_from_unix(errno);
+               }
+       }
+       return NT_STATUS_OK;
+}
+
 /*
   generate a file_id from a stat structure
  */
@@ -1387,10 +1417,12 @@ int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
 }
 
 int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
-                             struct files_struct *fsp, uint32 share_mode)
+                             struct files_struct *fsp, uint32 share_mode,
+                             uint32_t access_mask)
 {
        VFS_FIND(kernel_flock);
-       return handle->fns->kernel_flock(handle, fsp, share_mode);
+       return handle->fns->kernel_flock(handle, fsp, share_mode,
+                                        access_mask);
 }
 
 int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,

diff --git a/source3/torture/torture.c b/source3/torture/torture.c
index 9e1ac7648ed606ecafa8f884c25dbc52c22eee8d..e9d03eace8a993eb999e3f6910c508c386939e53 100644 (file)
--- a/source3/torture/torture.c
+++ b/source3/torture/torture.c
@@ -5271,6 +5271,408 @@ static bool run_chain2(int dummy)
        return True;
 }
 
+
+struct torture_createdel_state {
+       struct tevent_context *ev;
+       struct cli_state *cli;
+};
+
+static void torture_createdel_created(struct tevent_req *subreq);
+static void torture_createdel_closed(struct tevent_req *subreq);
+
+static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
+                                                struct tevent_context *ev,
+                                                struct cli_state *cli,
+                                                const char *name)
+{
+       struct tevent_req *req, *subreq;
+       struct torture_createdel_state *state;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct torture_createdel_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->cli = cli;
+
+       subreq = cli_ntcreate_send(
+               state, ev, cli, name, 0,
+               FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+               FILE_ATTRIBUTE_NORMAL,
+               FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+               FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
+
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, torture_createdel_created, req);
+       return req;
+}
+
+static void torture_createdel_created(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct torture_createdel_state *state = tevent_req_data(
+               req, struct torture_createdel_state);
+       NTSTATUS status;
+       uint16_t fnum;
+
+       status = cli_ntcreate_recv(subreq, &fnum);
+       TALLOC_FREE(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_ntcreate_recv returned %s\n",
+                          nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       subreq = cli_close_send(state, state->ev, state->cli, fnum);
+       if (tevent_req_nomem(subreq, req)) {
+               return;
+       }
+       tevent_req_set_callback(subreq, torture_createdel_closed, req);
+}
+
+static void torture_createdel_closed(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       NTSTATUS status;
+
+       status = cli_close_recv(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+       tevent_req_done(req);
+}
+
+static NTSTATUS torture_createdel_recv(struct tevent_req *req)
+{
+       return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct torture_createdels_state {
+       struct tevent_context *ev;
+       struct cli_state *cli;
+       const char *base_name;
+       int sent;
+       int received;
+       int num_files;
+       struct tevent_req **reqs;
+};
+
+static void torture_createdels_done(struct tevent_req *subreq);
+
+static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
+                                                 struct tevent_context *ev,
+                                                 struct cli_state *cli,
+                                                 const char *base_name,
+                                                 int num_parallel,
+                                                 int num_files)
+{
+       struct tevent_req *req;
+       struct torture_createdels_state *state;
+       int i;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct torture_createdels_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->cli = cli;
+       state->base_name = talloc_strdup(state, base_name);
+       if (tevent_req_nomem(state->base_name, req)) {
+               return tevent_req_post(req, ev);
+       }
+       state->num_files = MAX(num_parallel, num_files);
+       state->sent = 0;
+       state->received = 0;
+
+       state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
+       if (tevent_req_nomem(state->reqs, req)) {
+               return tevent_req_post(req, ev);
+       }
+
+       for (i=0; i<num_parallel; i++) {
+               char *name;
+
+               name = talloc_asprintf(state, "%s%8.8d", state->base_name,
+                                      state->sent);
+               if (tevent_req_nomem(name, req)) {
+                       return tevent_req_post(req, ev);
+               }
+               state->reqs[i] = torture_createdel_send(
+                       state->reqs, state->ev, state->cli, name);
+               if (tevent_req_nomem(state->reqs[i], req)) {
+                       return tevent_req_post(req, ev);
+               }
+               name = talloc_move(state->reqs[i], &name);
+               tevent_req_set_callback(state->reqs[i],
+                                       torture_createdels_done, req);
+               state->sent += 1;
+       }
+       return req;
+}
+
+static void torture_createdels_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct torture_createdels_state *state = tevent_req_data(
+               req, struct torture_createdels_state);
+       size_t num_parallel = talloc_array_length(state->reqs);
+       NTSTATUS status;
+       char *name;
+       int i;
+
+       status = torture_createdel_recv(subreq);
+       if (!NT_STATUS_IS_OK(status)){
+               DEBUG(10, ("torture_createdel_recv returned %s\n",
+                          nt_errstr(status)));
+               TALLOC_FREE(subreq);
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       for (i=0; i<num_parallel; i++) {
+               if (subreq == state->reqs[i]) {
+                       break;
+               }
+       }
+       if (i == num_parallel) {
+               DEBUG(10, ("received something we did not send\n"));
+               tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+               return;
+       }
+       TALLOC_FREE(state->reqs[i]);
+
+       if (state->sent >= state->num_files) {
+               tevent_req_done(req);
+               return;
+       }
+
+       name = talloc_asprintf(state, "%s%8.8d", state->base_name,
+                              state->sent);
+       if (tevent_req_nomem(name, req)) {
+               return;
+       }
+       state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
+                                               state->cli, name);
+       if (tevent_req_nomem(state->reqs[i], req)) {
+               return;
+       }
+       name = talloc_move(state->reqs[i], &name);
+       tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
+       state->sent += 1;
+}
+
+static NTSTATUS torture_createdels_recv(struct tevent_req *req)
+{
+       return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct swallow_notify_state {
+       struct tevent_context *ev;
+       struct cli_state *cli;
+       uint16_t fnum;
+       uint32_t completion_filter;
+       bool recursive;
+       bool (*fn)(uint32_t action, const char *name, void *priv);
+       void *priv;
+};
+
+static void swallow_notify_done(struct tevent_req *subreq);
+
+static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             struct cli_state *cli,
+                                             uint16_t fnum,
+                                             uint32_t completion_filter,
+                                             bool recursive,
+                                             bool (*fn)(uint32_t action,
+                                                        const char *name,
+                                                        void *priv),
+                                             void *priv)
+{
+       struct tevent_req *req, *subreq;
+       struct swallow_notify_state *state;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct swallow_notify_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->cli = cli;
+       state->fnum = fnum;
+       state->completion_filter = completion_filter;
+       state->recursive = recursive;
+       state->fn = fn;
+       state->priv = priv;
+
+       subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
+                                0xffff, state->completion_filter,
+                                state->recursive);
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, swallow_notify_done, req);
+       return req;
+}
+
+static void swallow_notify_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct swallow_notify_state *state = tevent_req_data(
+               req, struct swallow_notify_state);
+       NTSTATUS status;
+       uint32_t i, num_changes;
+       struct notify_change *changes;
+
+       status = cli_notify_recv(subreq, state, &num_changes, &changes);
+       TALLOC_FREE(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_notify_recv returned %s\n",
+                          nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       for (i=0; i<num_changes; i++) {
+               state->fn(changes[i].action, changes[i].name, state->priv);
+       }
+       TALLOC_FREE(changes);
+
+       subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
+                                0xffff, state->completion_filter,
+                                state->recursive);
+       if (tevent_req_nomem(subreq, req)) {
+               return;
+       }
+       tevent_req_set_callback(subreq, swallow_notify_done, req);
+}
+
+static bool print_notifies(uint32_t action, const char *name, void *priv)
+{
+       if (DEBUGLEVEL > 5) {
+               d_printf("%d %s\n", (int)action, name);
+       }
+       return true;
+}
+
+static void notify_bench_done(struct tevent_req *req)
+{
+       int *num_finished = (int *)tevent_req_callback_data_void(req);
+       *num_finished += 1;
+}
+
+static bool run_notify_bench(int dummy)
+{
+       const char *dname = "\\notify-bench";
+       struct tevent_context *ev;
+       NTSTATUS status;
+       uint16_t dnum;
+       struct tevent_req *req1, *req2;
+       int i, num_unc_names;
+       int num_finished = 0;
+
+       printf("starting notify-bench test\n");
+
+       if (use_multishare_conn) {
+               char **unc_list;
+               unc_list = file_lines_load(multishare_conn_fname,
+                                          &num_unc_names, 0, NULL);
+               if (!unc_list || num_unc_names <= 0) {
+                       d_printf("Failed to load unc names list from '%s'\n",
+                                multishare_conn_fname);
+                       return false;
+               }
+               TALLOC_FREE(unc_list);
+       } else {
+               num_unc_names = 1;
+       }
+
+       ev = tevent_context_init(talloc_tos());
+       if (ev == NULL) {
+               d_printf("tevent_context_init failed\n");
+               return false;
+       }
+
+       for (i=0; i<num_unc_names; i++) {
+               struct cli_state *cli;
+               char *base_fname;
+
+               base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
+                                            dname, i);
+               if (base_fname == NULL) {
+                       return false;
+               }
+
+               if (!torture_open_connection(&cli, i)) {
+                       return false;
+               }
+
+               status = cli_ntcreate(cli, dname, 0,
+                                     MAXIMUM_ALLOWED_ACCESS,
+                                     0, FILE_SHARE_READ|FILE_SHARE_WRITE|
+                                     FILE_SHARE_DELETE,
+                                     FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
+                                     &dnum);
+
+               if (!NT_STATUS_IS_OK(status)) {
+                       d_printf("Could not create %s: %s\n", dname,
+                                nt_errstr(status));
+                       return false;
+               }
+
+               req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
+                                          FILE_NOTIFY_CHANGE_FILE_NAME |
+                                          FILE_NOTIFY_CHANGE_DIR_NAME |
+                                          FILE_NOTIFY_CHANGE_ATTRIBUTES |
+                                          FILE_NOTIFY_CHANGE_LAST_WRITE,
+                                          false, print_notifies, NULL);
+               if (req1 == NULL) {
+                       d_printf("Could not create notify request\n");
+                       return false;
+               }
+
+               req2 = torture_createdels_send(talloc_tos(), ev, cli,
+                                              base_fname, 10, torture_numops);
+               if (req2 == NULL) {
+                       d_printf("Could not create createdels request\n");
+                       return false;
+               }
+               TALLOC_FREE(base_fname);
+
+               tevent_req_set_callback(req2, notify_bench_done,
+                                       &num_finished);
+       }
+
+       while (num_finished < num_unc_names) {
+               int ret;
+               ret = tevent_loop_once(ev);
+               if (ret != 0) {
+                       d_printf("tevent_loop_once failed\n");
+                       return false;
+               }
+       }
+
+       if (!tevent_req_poll(req2, ev)) {
+               d_printf("tevent_req_poll failed\n");
+       }
+
+       status = torture_createdels_recv(req2);
+       d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
+
+       return true;
+}
+
 static bool run_mangle1(int dummy)
 {
        struct cli_state *cli;
@@ -6579,6 +6981,7 @@ static struct {
        { "GETADDRINFO", run_getaddrinfo_send, 0},
        { "TLDAP", run_tldap },
        { "STREAMERROR", run_streamerror },
+       { "NOTIFY-BENCH", run_notify_bench },
        { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
        { "LOCAL-GENCACHE", run_local_gencache, 0},
        { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},

diff --git a/source3/utils/net.c b/source3/utils/net.c
index 2063479808e1d4412fd36b8f67cf1fc9cb14d350..e8920e0b02fd1207deebc369e0a687da25f9b842 100644 (file)
--- a/source3/utils/net.c
+++ b/source3/utils/net.c
@@ -53,7 +53,7 @@ extern bool AllowDebugChange;
 /* end of internationalization section                                 */
 /***********************************************************************/
 
-uint32 get_sec_channel_type(const char *param)
+enum netr_SchannelType get_sec_channel_type(const char *param)
 {
        if (!(param && *param)) {
                return get_default_sec_channel();
@@ -91,7 +91,7 @@ static int net_changesecretpw(struct net_context *c, int argc,
                              const char **argv)
 {
         char *trust_pw;
-        uint32 sec_channel_type = SEC_CHAN_WKSTA;
+        enum netr_SchannelType sec_channel_type = SEC_CHAN_WKSTA;
 
        if(c->opt_force) {
                if (c->opt_stdin) {
@@ -702,13 +702,6 @@ static struct functable net_func[] = {
                N_("  Use 'net help registry' to get more information about "
                   "'net registry' commands.")
        },
-       {       "lua",
-               net_lua,
-               NET_TRANSPORT_LOCAL,
-               N_("Open a lua interpreter"),
-               N_("  Use 'net help lua' to get more information about 'net "
-                  "lua' commands.")
-       },
        {       "eventlog",
                net_eventlog,
                NET_TRANSPORT_LOCAL,

diff --git a/source3/utils/net_lua.c b/source3/utils/net_lua.c
deleted file mode 100644 (file)
index b1b0f79..0000000
--- a/source3/utils/net_lua.c
+++ /dev/null
@@ -1,386 +0,0 @@
-/*
- *  Unix SMB/CIFS implementation.
- *  Lua experiments
- *  Copyright (C) Volker Lendecke 2006
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "includes.h"
-#include "utils/net.h"
-
-#include "lua-5.1.4/src/lualib.h"
-#include "lua-5.1.4/src/lauxlib.h"
-
-#define SOCK_METATABLE "cade1208-9029-4d76-8748-426dfc1436f7"
-
-struct sock_userdata {
-       int fd;
-};
-
-static int sock_userdata_gc(lua_State *L)
-{
-       struct sock_userdata *p = (struct sock_userdata *)
-               luaL_checkudata(L, 1, SOCK_METATABLE);
-       close(p->fd);
-       return 0;
-}
-
-static int sock_userdata_tostring(lua_State *L)
-{
-       struct sock_userdata *p = (struct sock_userdata *)
-               luaL_checkudata(L, 1, SOCK_METATABLE);
-
-       lua_pushfstring(L, "socket: %d", p->fd);
-       return 1;
-}
-
-static int sock_userdata_connect(lua_State *L)
-{
-       struct sock_userdata *p = (struct sock_userdata *)
-               luaL_checkudata(L, 1, SOCK_METATABLE);
-       const char *hostname;
-       int port;
-       struct sockaddr_in addr;
-       int res;
-
-       if (!lua_isstring(L, 2)) {
-               luaL_error(L, _("connect: Expected IP-Address"));
-       }
-       hostname = lua_tostring(L, 2);
-
-       if (!lua_isnumber(L, 3)) {
-               luaL_error(L, _("connect: Expected port"));
-       }
-       port = lua_tointeger(L, 3);
-
-       if (lua_gettop(L) == 4) {
-               /*
-                * Here we expect an event context in the last argument to
-                * make connect() asynchronous.
-                */
-       }
-
-       addr.sin_family = AF_INET;
-       inet_aton(hostname, &addr.sin_addr);
-       addr.sin_port = htons(port);
-
-       res = connect(p->fd, (struct sockaddr *)&addr, sizeof(addr));
-       if (res == -1) {
-               int err = errno;
-               lua_pushnil(L);
-               lua_pushfstring(L, _("connect failed: %s"), strerror(err));
-               return 2;
-       }
-
-       lua_pushboolean(L, 1);
-       return 1;
-}
-
-static const struct luaL_Reg sock_methods[] = {
-       {"__gc",        sock_userdata_gc},
-       {"__tostring",  sock_userdata_tostring},
-       {"connect",     sock_userdata_connect},
-       {NULL, NULL}
-};
-
-static const struct {
-       const char *name;
-       int domain;
-} socket_domains[] = {
-       {"PF_UNIX", PF_UNIX},
-       {"PF_INET", PF_INET},
-       {NULL, 0},
-};
-
-static const struct {
-       const char *name;
-       int type;
-} socket_types[] = {
-       {"SOCK_STREAM", SOCK_STREAM},
-       {"SOCK_DGRAM", SOCK_DGRAM},
-       {NULL, 0},
-};
-
-static int sock_userdata_new(lua_State *L)
-{
-       struct sock_userdata *result;
-       const char *domain_str = luaL_checkstring(L, 1);
-       const char *type_str = luaL_checkstring(L, 2);
-       int i, domain, type;
-
-       i = 0;
-       while (socket_domains[i].name != NULL) {
-               if (strcmp(domain_str, socket_domains[i].name) == 0) {
-                       break;
-               }
-               i += 1;
-       }
-       if (socket_domains[i].name == NULL) {
-               return luaL_error(L, _("socket domain %s unknown"), domain_str);
-       }
-       domain = socket_domains[i].domain;
-
-       i = 0;
-       while (socket_types[i].name != NULL) {
-               if (strcmp(type_str, socket_types[i].name) == 0) {
-                       break;
-               }
-               i += 1;
-       }
-       if (socket_types[i].name == NULL) {
-               return luaL_error(L, _("socket type %s unknown"), type_str);
-       }
-       type = socket_types[i].type;
-
-       result = (struct sock_userdata *)lua_newuserdata(L, sizeof(*result));
-       ZERO_STRUCTP(result);
-
-       result->fd = socket(domain, type, 0);
-       if (result->fd == -1) {
-               int err = errno;
-               lua_pushnil(L);
-               lua_pushfstring(L, _("socket() failed: %s"), strerror(errno));
-               lua_pushinteger(L, err);
-               return 3;
-       }
-
-       luaL_getmetatable(L, SOCK_METATABLE);
-       lua_setmetatable(L, -2);
-       return 1;
-}
-
-static const struct luaL_Reg sock_funcs[] = {
-       {"new",         sock_userdata_new},
-       {NULL, NULL}
-};
-
-static int sock_lua_init(lua_State *L, const char *libname) {
-       luaL_newmetatable(L, SOCK_METATABLE);
-
-       lua_pushvalue(L, -1);
-       lua_setfield(L, -2, "__index");
-
-       luaL_register(L, NULL, sock_methods);
-       luaL_register(L, libname, sock_funcs);
-       return 1;
-}
-
-#define EVT_METATABLE "c42e0642-b24a-40f0-8483-d8eb4aee9ea3"
-
-/*
- * The userdata we allocate from lua when a new event context is created
- */
-struct evt_userdata {
-       struct event_context *ev;
-};
-
-static bool evt_is_main_thread(lua_State *L) {
-       int ret;
-
-       ret = lua_pushthread(L);
-       lua_pop(L, 1);
-       return (ret != 0);
-}
-
-/*
- * Per event we allocate a struct thread_reference to keep the coroutine from
- * being garbage-collected. This is also the hook to find the right thread to
- * be resumed.
- */
-
-struct thread_reference {
-       struct lua_State *L;
-       /*
-        * Reference to the Thread (i.e. lua_State) this event is hanging on
-        */
-       int thread_ref;
-};
-
-static int thread_reference_destructor(struct thread_reference *ref)
-{
-       luaL_unref(ref->L, LUA_REGISTRYINDEX, ref->thread_ref);
-       return 0;
-}
-
-static struct thread_reference *evt_reference_thread(TALLOC_CTX *mem_ctx,
-                                                    lua_State *L)
-{
-       struct thread_reference *result;
-
-       result = talloc(mem_ctx, struct thread_reference);
-       if (result == NULL) {
-               return NULL;
-       }
-
-       lua_pushthread(L);
-       result->thread_ref = luaL_ref(L, LUA_REGISTRYINDEX);
-       result->L = L;
-       talloc_set_destructor(result, thread_reference_destructor);
-
-       return result;
-}
-
-static int evt_userdata_gc(lua_State *L)
-{
-       struct evt_userdata *p = (struct evt_userdata *)
-               luaL_checkudata(L, 1, EVT_METATABLE);
-       TALLOC_FREE(p->ev);
-       return 0;
-}
-
-static int evt_userdata_tostring(lua_State *L) {
-       lua_pushstring(L, "event context");
-       return 1;
-}
-
-static void evt_userdata_sleep_done(struct event_context *event_ctx,
-                                  struct timed_event *te,
-                                  struct timeval now,
-                                  void *priv)
-{
-       struct thread_reference *ref = talloc_get_type_abort(
-               priv, struct thread_reference);
-       lua_resume(ref->L, 0);
-       TALLOC_FREE(ref);
-}
-
-static int evt_userdata_sleep(lua_State *L)
-{
-       struct evt_userdata *p = (struct evt_userdata *)
-               luaL_checkudata(L, 1, EVT_METATABLE);
-       lua_Integer usecs = luaL_checkint(L, 2);
-       struct thread_reference *ref;
-       struct timed_event *te;
-
-       if (evt_is_main_thread(L)) {
-               /*
-                * Block in the main thread
-                */
-               smb_msleep(usecs/1000);
-               return 0;
-       }
-
-       ref = evt_reference_thread(p->ev, L);
-       if (ref == NULL) {
-               return luaL_error(L, _("evt_reference_thread failed\n"));
-       }
-
-       te = event_add_timed(p->ev, ref, timeval_current_ofs(0, usecs),
-                            evt_userdata_sleep_done,
-                            ref);
-
-       if (te == NULL) {
-               TALLOC_FREE(ref);
-               return luaL_error(L, _("event_add_timed failed"));
-       }
-
-       return lua_yield(L, 0);
-}
-
-static int evt_userdata_once(lua_State *L)
-{
-       struct evt_userdata *p = (struct evt_userdata *)
-               luaL_checkudata(L, 1, EVT_METATABLE);
-
-       if (!evt_is_main_thread(L)) {
-               return luaL_error(L,
-                                 _("event_once called from non-base thread"));
-       }
-
-       lua_pushinteger(L, event_loop_once(p->ev));
-       return 1;
-}
-
-static const struct luaL_Reg evt_methods[] = {
-       {"__gc",        evt_userdata_gc},
-       {"__tostring",  evt_userdata_tostring},
-       {"sleep",       evt_userdata_sleep},
-       {"once",        evt_userdata_once},
-       {NULL, NULL}
-};
-
-static int evt_userdata_new(lua_State *L) {
-       struct evt_userdata *result;
-
-       result = (struct evt_userdata *)lua_newuserdata(L, sizeof(*result));
-       ZERO_STRUCTP(result);
-
-       result->ev = event_context_init(NULL);
-       if (result->ev == NULL) {
-               return luaL_error(L, _("event_context_init failed"));
-       }
-
-       luaL_getmetatable(L, EVT_METATABLE);
-       lua_setmetatable(L, -2);
-       return 1;
-}
-
-static const struct luaL_Reg evt_funcs[] = {
-       {"new",         evt_userdata_new},
-       {NULL, NULL}
-};
-
-static int evt_lua_init(lua_State *L, const char *libname) {
-       luaL_newmetatable(L, EVT_METATABLE);
-
-       lua_pushvalue(L, -1);
-       lua_setfield(L, -2, "__index");
-
-       luaL_register(L, NULL, evt_methods);
-       luaL_register(L, libname, evt_funcs);
-       return 1;
-}
-
-int net_lua(struct net_context *c, int argc, const char **argv)
-{
-       lua_State *state;
-
-       state = lua_open();
-       if (state == NULL) {
-               d_fprintf(stderr, _("lua_newstate failed\n"));
-               return -1;
-       }
-
-       luaL_openlibs(state);
-       evt_lua_init(state, "event");
-       sock_lua_init(state, "socket");
-
-       while (1) {
-               char *line = NULL;
-
-               line = smb_readline("lua> ", NULL, NULL);
-               if (line == NULL) {
-                       break;
-               }
-
-               if (line[0] == ':') {
-                       if (luaL_dofile(state, &line[1])) {
-                               d_printf(_("luaL_dofile returned an error\n"));
-                               continue;
-                       }
-               } else if (line[0] != '\n') {
-                       if (luaL_dostring(state, line) != 0) {
-                               d_printf(_("luaL_dostring returned an "
-                                          "error\n"));
-                       }
-               }
-
-               SAFE_FREE(line);
-       }
-
-       lua_close(state);
-       return -1;
-}

diff --git a/source3/utils/net_proto.h b/source3/utils/net_proto.h
index 75ac032db92c8c6bf67f87201224c12ec9132f88..098e2a22be6b486db68ed0f891258dc900664b71 100644 (file)
--- a/source3/utils/net_proto.h
+++ b/source3/utils/net_proto.h
@@ -42,7 +42,7 @@ void debug_unix_user_token(int dbg_class, int dbg_lev, uid_t uid, gid_t gid,
 
 /* The following definitions come from utils/net.c  */
 
-uint32 get_sec_channel_type(const char *param);
+enum netr_SchannelType get_sec_channel_type(const char *param);
 
 /* The following definitions come from utils/net_ads.c  */
 
@@ -423,10 +423,6 @@ int net_usershare_usage(struct net_context *c, int argc, const char **argv);
 int net_usershare_help(struct net_context *c, int argc, const char **argv);
 int net_usershare(struct net_context *c, int argc, const char **argv);
 
-/* The following definitions come from utils/net_lua.c  */
-
-int net_lua(struct net_context *c, int argc, const char **argv);
-
 /* The following definitions come from utils/net_eventlog.c  */
 
 int net_eventlog(struct net_context *c, int argc, const char **argv);

diff --git a/source3/utils/net_rpc.c b/source3/utils/net_rpc.c
index b4505347b1f0e1aa7d497fa528190214f41d4e3a..455405a3ee899a37a691bbb3cb5227e349f31959 100644 (file)
--- a/source3/utils/net_rpc.c
+++ b/source3/utils/net_rpc.c
@@ -239,8 +239,16 @@ static NTSTATUS rpc_changetrustpw_internals(struct net_context *c,
                                        int argc,
                                        const char **argv)
 {
+       NTSTATUS status;
+
+       status = trust_pw_find_change_and_store_it(pipe_hnd, mem_ctx, c->opt_target_workgroup);
+       if (!NT_STATUS_IS_OK(status)) {
+               d_fprintf(stderr, _("Failed to change machine account password: %s\n"),
+                       nt_errstr(status));
+               return status;
+       }
 
-       return trust_pw_find_change_and_store_it(pipe_hnd, mem_ctx, c->opt_target_workgroup);
+       return NT_STATUS_OK;
 }
 
 /**
@@ -301,7 +309,7 @@ static NTSTATUS rpc_oldjoin_internals(struct net_context *c,
        fstring trust_passwd;
        unsigned char orig_trust_passwd_hash[16];
        NTSTATUS result;
-       uint32 sec_channel_type;
+       enum netr_SchannelType sec_channel_type;
 
        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_netlogon.syntax_id,
                                          &pipe_hnd);
@@ -336,6 +344,7 @@ static NTSTATUS rpc_oldjoin_internals(struct net_context *c,
        E_md4hash(trust_passwd, orig_trust_passwd_hash);
 
        result = trust_pw_change_and_store_it(pipe_hnd, mem_ctx, c->opt_target_workgroup,
+                                             global_myname(),
                                              orig_trust_passwd_hash,
                                              sec_channel_type);
 
@@ -5768,18 +5777,12 @@ static NTSTATUS rpc_query_domain_sid(struct net_context *c,
 
 static void print_trusted_domain(DOM_SID *dom_sid, const char *trusted_dom_name)
 {
-       fstring ascii_sid, padding;
-       int pad_len, col_len = 20;
+       fstring ascii_sid;
 
        /* convert sid into ascii string */
        sid_to_fstring(ascii_sid, dom_sid);
 
-       /* calculate padding space for d_printf to look nicer */
-       pad_len = col_len - strlen(trusted_dom_name);
-       padding[pad_len] = 0;
-       do padding[--pad_len] = ' '; while (pad_len);
-
-       d_printf("%s%s%s\n", trusted_dom_name, padding, ascii_sid);
+       d_printf("%-20s%s\n", trusted_dom_name, ascii_sid);
 }
 
 static NTSTATUS vampire_trusted_domain(struct rpc_pipe_client *pipe_hnd,
@@ -6003,14 +6006,13 @@ static int rpc_trustdom_list(struct net_context *c, int argc, const char **argv)
        NTSTATUS nt_status;
        const char *domain_name = NULL;
        DOM_SID *queried_dom_sid;
-       fstring padding;
        int ascii_dom_name_len;
        struct policy_handle connect_hnd;
        union lsa_PolicyInformation *info = NULL;
 
        /* trusted domains listing variables */
        unsigned int num_domains, enum_ctx = 0;
-       int i, pad_len, col_len = 20;
+       int i;
        struct lsa_DomainList dom_list;
        fstring pdc_name;
 
@@ -6021,7 +6023,7 @@ static int rpc_trustdom_list(struct net_context *c, int argc, const char **argv)
        if (c->display_usage) {
                d_printf(_("Usage:\n"
                           "net rpc trustdom list\n"
-                          "    List trust relationships\n"));
+                          "    List in- and outgoing trust relationships\n"));
                return 0;
        }
 
@@ -6219,17 +6221,12 @@ static int rpc_trustdom_list(struct net_context *c, int argc, const char **argv)
                        if (ascii_dom_name_len && ascii_dom_name_len < FSTRING_LEN)
                                str[ascii_dom_name_len - 1] = '\0';
 
-                       /* calculate padding space for d_printf to look nicer */
-                       pad_len = col_len - strlen(str);
-                       padding[pad_len] = 0;
-                       do padding[--pad_len] = ' '; while (pad_len);
-
                        /* set opt_* variables to remote domain */
                        strupper_m(str);
                        c->opt_workgroup = talloc_strdup(mem_ctx, str);
                        c->opt_target_workgroup = c->opt_workgroup;
 
-                       d_printf("%s%s", str, padding);
+                       d_printf("%-20s", str);
 
                        /* connect to remote domain controller */
                        nt_status = net_make_ipc_connection(c,
@@ -6292,41 +6289,41 @@ static int rpc_trustdom(struct net_context *c, int argc, const char **argv)
                        "add",
                        rpc_trustdom_add,
                        NET_TRANSPORT_RPC,
-                       N_("Add trusted domain's account"),
+                       N_("Add trusting domain's account"),
                        N_("net rpc trustdom add\n"
-                          "    Add trusted domain's account")
+                          "    Add trusting domain's account")
                },
                {
                        "del",
                        rpc_trustdom_del,
                        NET_TRANSPORT_RPC,
-                       N_("Remove trusted domain's account"),
+                       N_("Remove trusting domain's account"),
                        N_("net rpc trustdom del\n"
-                          "    Remove trusted domain's account")
+                          "    Remove trusting domain's account")
                },
                {
                        "establish",
                        rpc_trustdom_establish,
                        NET_TRANSPORT_RPC,
-                       N_("Establish trust relationship"),
+                       N_("Establish outgoing trust relationship"),
                        N_("net rpc trustdom establish\n"
-                          "    Establish trust relationship")
+                          "    Establish outgoing trust relationship")
                },
                {
                        "revoke",
                        rpc_trustdom_revoke,
                        NET_TRANSPORT_RPC,
-                       N_("Revoke trust relationship"),
+                       N_("Revoke outgoing trust relationship"),
                        N_("net rpc trustdom revoke\n"
-                          "    Revoke trust relationship")
+                          "    Revoke outgoing trust relationship")
                },
                {
                        "list",
                        rpc_trustdom_list,
                        NET_TRANSPORT_RPC,
-                       N_("List domain trusts"),
+                       N_("List in- and outgoing domain trusts"),
                        N_("net rpc trustdom list\n"
-                          "    List domain trusts")
+                          "    List in- and outgoing domain trusts")
                },
                {
                        "vampire",

diff --git a/source3/utils/net_rpc_audit.c b/source3/utils/net_rpc_audit.c
index f0b440d3bea3c44f979b0da96338813768c6fa6e..bc3ed3dba24add0e48495f8440906ab31b584f9e 100644 (file)
--- a/source3/utils/net_rpc_audit.c
+++ b/source3/utils/net_rpc_audit.c
@@ -40,9 +40,6 @@ static int net_help_audit(struct net_context *c, int argc, const char **argv)
 
 static void print_auditing_category(const char *policy, const char *value)
 {
-       fstring padding;
-       int pad_len, col_len = 30;
-
        if (policy == NULL) {
                policy = N_("Unknown");
        }
@@ -50,12 +47,7 @@ static void print_auditing_category(const char *policy, const char *value)
                value = N_("Invalid");
        }
 
-       /* calculate padding space for d_printf to look nicer */
-       pad_len = col_len - strlen(policy);
-       padding[pad_len] = 0;
-       do padding[--pad_len] = ' '; while (pad_len > 0);
-
-       d_printf(_("\t%s%s%s\n"), policy, padding, value);
+       d_printf(_("\t%-30s%s\n"), policy, value);
 }
 
 /********************************************************************

diff --git a/source3/utils/net_rpc_join.c b/source3/utils/net_rpc_join.c
index 23913812b05f88b24ef17d273685a498aea71535..fd81205a9599625a44e834aa4461701a0201c7ed 100644 (file)
--- a/source3/utils/net_rpc_join.c
+++ b/source3/utils/net_rpc_join.c
@@ -138,7 +138,7 @@ int net_rpc_join_newstyle(struct net_context *c, int argc, const char **argv)
        TALLOC_CTX *mem_ctx;
         uint32 acb_info = ACB_WSTRUST;
        uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
-       uint32 sec_channel_type;
+       enum netr_SchannelType sec_channel_type;
        struct rpc_pipe_client *pipe_hnd = NULL;
 
        /* rpc variables */
@@ -186,6 +186,10 @@ int net_rpc_join_newstyle(struct net_context *c, int argc, const char **argv)
                acb_info = ACB_DOMTRUST;
                break;
 #endif
+       default:
+               DEBUG(0,("secure channel type %d not yet supported\n",
+                       sec_channel_type));
+               break;
        }
 
        /* Make authenticated connection to remote machine */

diff --git a/source3/utils/net_rpc_printer.c b/source3/utils/net_rpc_printer.c
index ea7465e33a5ac47d84ae5b254be3417a7dba0673..5652caf8341725c85c45c3f99d5b7a43d0e20adc 100644 (file)
--- a/source3/utils/net_rpc_printer.c
+++ b/source3/utils/net_rpc_printer.c
@@ -72,7 +72,8 @@ static void display_print_driver3(struct spoolss_DriverInfo3 *r)
 
 static void display_reg_value(const char *subkey, struct regval_blob value)
 {
-       char *text;
+       const char *text;
+       DATA_BLOB blob;
 
        switch(value.type) {
        case REG_DWORD:
@@ -81,11 +82,8 @@ static void display_reg_value(const char *subkey, struct regval_blob value)
                break;
 
        case REG_SZ:
-               rpcstr_pull_talloc(talloc_tos(),
-                               &text,
-                               value.data_p,
-                               value.size,
-                               STR_TERMINATE);
+               blob = data_blob_const(value.data_p, value.size);
+               pull_reg_sz(talloc_tos(), &blob, &text);
                if (!text) {
                        break;
                }
@@ -100,17 +98,17 @@ static void display_reg_value(const char *subkey, struct regval_blob value)
                break;
 
        case REG_MULTI_SZ: {
-               uint32_t i, num_values;
-               char **values;
+               uint32_t i;
+               const char **values;
+               blob = data_blob_const(value.data_p, value.size);
 
-               if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
-                                                    value.size, &num_values,
-                                                    &values))) {
-                       d_printf(_("reg_pull_multi_sz failed\n"));
+               if (!pull_reg_multi_sz(NULL, &blob, &values)) {
+                       d_printf("pull_reg_multi_sz failed\n");
                        break;
                }
 
-               for (i=0; i<num_values; i++) {
+               printf("%s: REG_MULTI_SZ: \n", value.valuename);
+               for (i=0; values[i] != NULL; i++) {
                        d_printf("%s\n", values[i]);
                }
                TALLOC_FREE(values);
@@ -2418,7 +2416,7 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
                        for (j=0; j < count; j++) {
 
                                struct regval_blob value;
-                               UNISTR2 data;
+                               DATA_BLOB blob;
 
                                /* although samba replies with sane data in most cases we
                                   should try to avoid writing wrong registry data */
@@ -2432,7 +2430,7 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
                                        if (strequal(info[j].value_name, SPOOL_REG_PORTNAME)) {
 
                                                /* although windows uses a multi-sz, we use a sz */
-                                               init_unistr2(&data, SAMBA_PRINTER_PORT_NAME, UNI_STR_TERMINATE);
+                                               push_reg_sz(mem_ctx, &blob, SAMBA_PRINTER_PORT_NAME);
                                                fstrcpy(value.valuename, SPOOL_REG_PORTNAME);
                                        }
 
@@ -2442,7 +2440,7 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
                                                        nt_status = NT_STATUS_NO_MEMORY;
                                                        goto done;
                                                }
-                                               init_unistr2(&data, unc_name, UNI_STR_TERMINATE);
+                                               push_reg_sz(mem_ctx, &blob, unc_name);
                                                fstrcpy(value.valuename, SPOOL_REG_UNCNAME);
                                        }
 
@@ -2456,27 +2454,27 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
                                                        nt_status = NT_STATUS_NO_MEMORY;
                                                        goto done;
                                                }
-                                               init_unistr2(&data, url, UNI_STR_TERMINATE);
+                                               push_reg_sz(mem_ctx, &blob, url);
                                                fstrcpy(value.valuename, SPOOL_REG_URL);
 #endif
                                        }
 
                                        if (strequal(info[j].value_name, SPOOL_REG_SERVERNAME)) {
 
-                                               init_unistr2(&data, longname, UNI_STR_TERMINATE);
+                                               push_reg_sz(mem_ctx, &blob, longname);
                                                fstrcpy(value.valuename, SPOOL_REG_SERVERNAME);
                                        }
 
                                        if (strequal(info[j].value_name, SPOOL_REG_SHORTSERVERNAME)) {
 
-                                               init_unistr2(&data, global_myname(), UNI_STR_TERMINATE);
+                                               push_reg_sz(mem_ctx, &blob, global_myname());
                                                fstrcpy(value.valuename, SPOOL_REG_SHORTSERVERNAME);
                                        }
 
                                        value.type = REG_SZ;
-                                       value.size = data.uni_str_len * 2;
+                                       value.size = blob.length;
                                        if (value.size) {
-                                               value.data_p = (uint8_t *)TALLOC_MEMDUP(mem_ctx, data.buffer, value.size);
+                                               value.data_p = blob.data;
                                        } else {
                                                value.data_p = NULL;
                                        }
@@ -2492,7 +2490,6 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
                                } else {
 
                                        struct regval_blob v;
-                                       DATA_BLOB blob;
 
                                        result = push_spoolss_PrinterData(mem_ctx, &blob,
                                                                          info[j].type,

diff --git a/source3/utils/net_rpc_registry.c b/source3/utils/net_rpc_registry.c
index 1ad1d74ca0853c7ff70e783853996d5b362ea451..36e83a75af8e1bdf07f44d1caa1ca95208d1baa3 100644 (file)
--- a/source3/utils/net_rpc_registry.c
+++ b/source3/utils/net_rpc_registry.c
@@ -23,6 +23,46 @@
 #include "regfio.h"
 #include "reg_objects.h"
 
+/*******************************************************************
+ connect to a registry hive root (open a registry policy)
+*******************************************************************/
+
+static NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+                                     uint32_t reg_type, uint32_t access_mask,
+                                     struct policy_handle *reg_hnd)
+{
+       ZERO_STRUCTP(reg_hnd);
+
+       switch (reg_type)
+       {
+       case HKEY_CLASSES_ROOT:
+               return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL,
+                       access_mask, reg_hnd, NULL);
+
+       case HKEY_LOCAL_MACHINE:
+               return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL,
+                       access_mask, reg_hnd, NULL);
+
+       case HKEY_USERS:
+               return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL,
+                       access_mask, reg_hnd, NULL);
+
+       case HKEY_CURRENT_USER:
+               return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL,
+                       access_mask, reg_hnd, NULL);
+
+       case HKEY_PERFORMANCE_DATA:
+               return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL,
+                       access_mask, reg_hnd, NULL);
+
+       default:
+               /* fall through to end of function */
+               break;
+       }
+
+       return NT_STATUS_INVALID_PARAMETER;
+}
+
 static bool reg_hive_key(TALLOC_CTX *ctx, const char *fullname,
                         uint32 *reg_type, const char **key_name)
 {
@@ -895,8 +935,9 @@ static int rpc_registry_save(struct net_context *c, int argc, const char **argv
 static void dump_values( REGF_NK_REC *nk )
 {
        int i, j;
-       char *data_str = NULL;
+       const char *data_str = NULL;
        uint32 data_size, data;
+       DATA_BLOB blob;
 
        if ( !nk->values )
                return;
@@ -908,11 +949,8 @@ static void dump_values( REGF_NK_REC *nk )
                data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
                switch ( nk->values[i].type ) {
                        case REG_SZ:
-                               rpcstr_pull_talloc(talloc_tos(),
-                                               &data_str,
-                                               nk->values[i].data,
-                                               -1,
-                                               STR_TERMINATE);
+                               blob = data_blob_const(nk->values[i].data, data_size);
+                               pull_reg_sz(talloc_tos(), &blob, &data_str);
                                if (!data_str) {
                                        break;
                                }

diff --git a/source3/winbindd/idmap_adex/provider_unified.c b/source3/winbindd/idmap_adex/provider_unified.c
index b6652f4e499a6d295eb14675a03a6853d2826420..af334057471b93635cfd162d29326e0c6a637922 100644 (file)
--- a/source3/winbindd/idmap_adex/provider_unified.c
+++ b/source3/winbindd/idmap_adex/provider_unified.c
@@ -440,7 +440,6 @@ done:
        }
 
        talloc_destroy(frame);
-       TALLOC_FREE(entry_dn);
 
        return nt_status;
 }

diff --git a/source3/winbindd/idmap_ldap.c b/source3/winbindd/idmap_ldap.c
index 3d1dd488d6bb11b55513659a2e2d0d1bf9454f66..375c04a0bf05fa5681a02692e62ba1f64e97fc46 100644 (file)
--- a/source3/winbindd/idmap_ldap.c
+++ b/source3/winbindd/idmap_ldap.c
@@ -131,6 +131,7 @@ static NTSTATUS get_credentials( TALLOC_CTX *mem_ctx,
                        DEBUG(2, ("get_credentials: Failed to lookup ldap "
                                  "bind creds. Using anonymous connection.\n"));
                        anon = True;
+                       *dn = NULL;
                } else {
                        *dn = talloc_strdup(mem_ctx, user_dn);
                        SAFE_FREE( user_dn );

diff --git a/source3/winbindd/nss_info.c b/source3/winbindd/nss_info.c
index 382aa86df0d9f6ada034031cca01d08c2ececfa6..663fc9a2a57ceaf1a90d8d9ceb5485ddf6a683ff 100644 (file)
--- a/source3/winbindd/nss_info.c
+++ b/source3/winbindd/nss_info.c
@@ -164,23 +164,25 @@ static NTSTATUS nss_domain_list_add_domain(const char *domain,
  to initialize the state on a per domain basis.
  *******************************************************************/
 
- NTSTATUS nss_init( const char **nss_list )
+static NTSTATUS nss_init(const char **nss_list)
 {
        NTSTATUS status;
-       static NTSTATUS nss_initialized = NT_STATUS_UNSUCCESSFUL;
+       static bool nss_initialized = false;
        int i;
        char *backend, *domain;
        struct nss_function_entry *nss_backend;
 
        /* check for previous successful initializations */
 
-       if ( NT_STATUS_IS_OK(nss_initialized) )
+       if (nss_initialized) {
                return NT_STATUS_OK;
+       }
 
-       /* The "template" backend should alqays be registered as it
+       /* The "template" backend should always be registered as it
           is a static module */
 
-       if ( (nss_backend = nss_get_backend( "template" )) == NULL ) {
+       nss_backend = nss_get_backend("template");
+       if (nss_backend == NULL) {
                static_init_nss_info;
        }
 
@@ -200,19 +202,21 @@ static NTSTATUS nss_domain_list_add_domain(const char *domain,
 
                /* validate the backend */
 
-               if ( (nss_backend = nss_get_backend( backend )) == NULL ) {
+               nss_backend = nss_get_backend(backend);
+               if (nss_backend == NULL) {
                        /* attempt to register the backend */
                        status = smb_probe_module( "nss_info", backend );
                        if ( !NT_STATUS_IS_OK(status) ) {
                                continue;
                        }
+               }
 
-                       /* try again */
-                       if ( (nss_backend = nss_get_backend( backend )) == NULL ) {
-                               DEBUG(0,("nss_init: unregistered backend %s!.  Skipping\n",
-                                        backend));
-                               continue;
-                       }
+               /* try again */
+               nss_backend = nss_get_backend(backend);
+               if (nss_backend == NULL) {
+                       DEBUG(0, ("nss_init: unregistered backend %s!. "
+                                 "Skipping\n", backend));
+                       continue;
                }
 
                /*
@@ -241,10 +245,10 @@ static NTSTATUS nss_domain_list_add_domain(const char *domain,
                         "Defaulting to \"template\".\n"));
 
 
-               /* we shouild default to use template here */
+               /* we should default to use template here */
        }
 
-       nss_initialized = NT_STATUS_OK;
+       nss_initialized = true;
 
        return NT_STATUS_OK;
 }
@@ -259,8 +263,8 @@ static struct nss_domain_entry *find_nss_domain( const char *domain )
 
        status = nss_init( lp_winbind_nss_info() );
        if ( !NT_STATUS_IS_OK(status) ) {
-               DEBUG(4,("nss_get_info: Failed to init nss_info API (%s)!\n",
-                        nt_errstr(status)));
+               DEBUG(4,("find_nss_domain: Failed to init nss_info API "
+                        "(%s)!\n", nt_errstr(status)));
                return NULL;
        }
 

diff --git a/source3/winbindd/wb_fill_pwent.c b/source3/winbindd/wb_fill_pwent.c
index 4f4819ca23026c870aeb3200ff7e7b52f9bdc831..8998bf991d1a6263994cfad6675b0460fca9b4fd 100644 (file)
--- a/source3/winbindd/wb_fill_pwent.c
+++ b/source3/winbindd/wb_fill_pwent.c
@@ -27,6 +27,14 @@ struct wb_fill_pwent_state {
        struct winbindd_pw *pw;
 };
 
+static bool fillup_pw_field(const char *lp_template,
+                           const char *username,
+                           const char *domname,
+                           uid_t uid,
+                           gid_t gid,
+                           const char *in,
+                           fstring out);
+
 static void wb_fill_pwent_sid2uid_done(struct tevent_req *subreq);
 static void wb_fill_pwent_sid2gid_done(struct tevent_req *subreq);
 
@@ -153,3 +161,42 @@ NTSTATUS wb_fill_pwent_recv(struct tevent_req *req)
 {
        return tevent_req_simple_recv_ntstatus(req);
 }
+
+static bool fillup_pw_field(const char *lp_template,
+                           const char *username,
+                           const char *domname,
+                           uid_t uid,
+                           gid_t gid,
+                           const char *in,
+                           fstring out)
+{
+       char *templ;
+
+       if (out == NULL)
+               return False;
+
+       /* The substitution of %U and %D in the 'template
+          homedir' is done by talloc_sub_specified() below.
+          If we have an in string (which means the value has already
+          been set in the nss_info backend), then use that.
+          Otherwise use the template value passed in. */
+
+       if ((in != NULL) && (in[0] != '\0') && (lp_security() == SEC_ADS)) {
+               templ = talloc_sub_specified(talloc_tos(), in,
+                                            username, domname,
+                                            uid, gid);
+       } else {
+               templ = talloc_sub_specified(talloc_tos(), lp_template,
+                                            username, domname,
+                                            uid, gid);
+       }
+
+       if (!templ)
+               return False;
+
+       safe_strcpy(out, templ, sizeof(fstring) - 1);
+       TALLOC_FREE(templ);
+
+       return True;
+
+}

diff --git a/source3/winbindd/wb_getpwsid.c b/source3/winbindd/wb_getpwsid.c
index 1295d5bcbc6355bdf3fdbe951eda29c44fe34bc9..4ccc51ae1875e51d0a5a574423c298e014b5fe18 100644 (file)
--- a/source3/winbindd/wb_getpwsid.c
+++ b/source3/winbindd/wb_getpwsid.c
@@ -31,8 +31,7 @@ struct wb_getpwsid_state {
 
 static void wb_getpwsid_queryuser_done(struct tevent_req *subreq);
 static void wb_getpwsid_lookupsid_done(struct tevent_req *subreq);
-static void wb_getpwsid_sid2uid_done(struct tevent_req *subreq);
-static void wb_getpwsid_sid2gid_done(struct tevent_req *subreq);
+static void wb_getpwsid_done(struct tevent_req *subreq);
 
 struct tevent_req *wb_getpwsid_send(TALLOC_CTX *mem_ctx,
                                    struct tevent_context *ev,
@@ -83,14 +82,14 @@ static void wb_getpwsid_queryuser_done(struct tevent_req *subreq)
            && (state->userinfo->acct_name[0] != '\0')) {
                /*
                 * QueryUser got us a name, let's got directly to the
-                * sid2uid step
+                * fill_pwent step
                 */
-               subreq = wb_sid2uid_send(state, state->ev,
-                                        &state->userinfo->user_sid);
+               subreq = wb_fill_pwent_send(state, state->ev, state->userinfo,
+                                           state->pw);
                if (tevent_req_nomem(subreq, req)) {
                        return;
                }
-               tevent_req_set_callback(subreq, wb_getpwsid_sid2uid_done, req);
+               tevent_req_set_callback(subreq, wb_getpwsid_done, req);
                return;
        }
 
@@ -122,93 +121,25 @@ static void wb_getpwsid_lookupsid_done(struct tevent_req *subreq)
                tevent_req_nterror(req, status);
                return;
        }
-       subreq = wb_sid2uid_send(state, state->ev, &state->userinfo->user_sid);
+       subreq = wb_fill_pwent_send(state, state->ev, state->userinfo,
+                                   state->pw);
        if (tevent_req_nomem(subreq, req)) {
                return;
        }
-       tevent_req_set_callback(subreq, wb_getpwsid_sid2uid_done, req);
+       tevent_req_set_callback(subreq, wb_getpwsid_done, req);
 }
 
-static void wb_getpwsid_sid2uid_done(struct tevent_req *subreq)
+static void wb_getpwsid_done(struct tevent_req *subreq)
 {
        struct tevent_req *req = tevent_req_callback_data(
                subreq, struct tevent_req);
-       struct wb_getpwsid_state *state = tevent_req_data(
-               req, struct wb_getpwsid_state);
-       NTSTATUS status;
-
-       status = wb_sid2uid_recv(subreq, &state->pw->pw_uid);
-       TALLOC_FREE(subreq);
-       if (!NT_STATUS_IS_OK(status)) {
-               tevent_req_nterror(req, status);
-               return;
-       }
-       subreq = wb_sid2gid_send(state, state->ev,
-                                &state->userinfo->group_sid);
-       if (tevent_req_nomem(subreq, req)) {
-               return;
-       }
-       tevent_req_set_callback(subreq, wb_getpwsid_sid2gid_done, req);
-}
-
-static void wb_getpwsid_sid2gid_done(struct tevent_req *subreq)
-{
-       struct tevent_req *req = tevent_req_callback_data(
-               subreq, struct tevent_req);
-       struct wb_getpwsid_state *state = tevent_req_data(
-               req, struct wb_getpwsid_state);
        NTSTATUS status;
-       char *username;
-       char *mapped_name;
 
-       status = wb_sid2gid_recv(subreq, &state->pw->pw_gid);
-       TALLOC_FREE(subreq);
+       status = wb_fill_pwent_recv(subreq);
        if (!NT_STATUS_IS_OK(status)) {
                tevent_req_nterror(req, status);
                return;
        }
-
-       username = talloc_strdup_lower(state, state->userinfo->acct_name);
-       if (tevent_req_nomem(username, req)) {
-               return;
-       }
-
-       status = normalize_name_map(state, state->user_domain, username,
-                                   &mapped_name);
-
-       if (NT_STATUS_IS_OK(status)
-           || NT_STATUS_EQUAL(status, NT_STATUS_FILE_RENAMED)) {
-               /*
-                * normalize_name_map did something
-                */
-               fstrcpy(state->pw->pw_name, mapped_name);
-               TALLOC_FREE(mapped_name);
-       } else {
-               fill_domain_username(state->pw->pw_name,
-                                    state->user_domain->name,
-                                    username, True);
-       }
-       fstrcpy(state->pw->pw_passwd, "*");
-       fstrcpy(state->pw->pw_gecos, state->userinfo->full_name);
-
-       if (!fillup_pw_field(lp_template_homedir(), username,
-                            state->user_domain->name, state->pw->pw_uid,
-                            state->pw->pw_gid, state->userinfo->homedir,
-                            state->pw->pw_dir)) {
-               DEBUG(5, ("Could not compose homedir\n"));
-               tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
-               return;
-       }
-
-       if (!fillup_pw_field(lp_template_shell(), state->pw->pw_name,
-                            state->user_domain->name, state->pw->pw_uid,
-                            state->pw->pw_gid, state->userinfo->shell,
-                            state->pw->pw_shell)) {
-               DEBUG(5, ("Could not compose shell\n"));
-               tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
-               return;
-       }
-
        tevent_req_done(req);
 }
 

diff --git a/source3/winbindd/winbindd.c b/source3/winbindd/winbindd.c
index f0160fcb78fbd95a54b49cf1b5321429f11912c7..e09374c5cb1842baf5e2f5200e2c1fba9047f90c 100644 (file)
--- a/source3/winbindd/winbindd.c
+++ b/source3/winbindd/winbindd.c
@@ -547,6 +547,8 @@ static struct winbindd_async_dispatch_table async_priv_table[] = {
          winbindd_remove_mapping_send, winbindd_remove_mapping_recv },
        { WINBINDD_SET_HWM, "SET_HWM",
          winbindd_set_hwm_send, winbindd_set_hwm_recv },
+       { WINBINDD_CHANGE_MACHACC, "CHANGE_MACHACC",
+         winbindd_change_machine_acct_send, winbindd_change_machine_acct_recv },
 
        { 0, NULL, NULL, NULL }
 };

diff --git a/source3/winbindd/winbindd_cache.c b/source3/winbindd/winbindd_cache.c
index 6d48fe5f857cc77da7422fb207de8a13104afd45..c4bc936a5d6aa5724ebaf57b0a99dad64e840e1f 100644 (file)
--- a/source3/winbindd/winbindd_cache.c
+++ b/source3/winbindd/winbindd_cache.c
@@ -4359,6 +4359,8 @@ static bool wcache_opnum_cacheable(uint32_t opnum)
        case NDR_WBINT_QUERYSEQUENCENUMBER:
        case NDR_WBINT_ALLOCATEUID:
        case NDR_WBINT_ALLOCATEGID:
+       case NDR_WBINT_CHECKMACHINEACCOUNT:
+       case NDR_WBINT_CHANGEMACHINEACCOUNT:
                return false;
        }
        return true;

diff --git a/source3/winbindd/winbindd_change_machine_acct.c b/source3/winbindd/winbindd_change_machine_acct.c
new file mode 100644 (file)
index 0000000..a49315d
--- /dev/null
+++ b/source3/winbindd/winbindd_change_machine_acct.c
@@ -0,0 +1,93 @@
+/*
+   Unix SMB/CIFS implementation.
+   async implementation of WINBINDD_CHANGE_MACHINE_ACCT
+   Copyright (C) Volker Lendecke 2009
+   Copyright (C) Guenther Deschner 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "winbindd.h"
+#include "librpc/gen_ndr/cli_wbint.h"
+
+struct winbindd_change_machine_acct_state {
+       uint8_t dummy;
+};
+
+static void winbindd_change_machine_acct_done(struct tevent_req *subreq);
+
+struct tevent_req *winbindd_change_machine_acct_send(TALLOC_CTX *mem_ctx,
+                                                    struct tevent_context *ev,
+                                                    struct winbindd_cli_state *cli,
+                                                    struct winbindd_request *request)
+{
+       struct tevent_req *req, *subreq;
+       struct winbindd_change_machine_acct_state *state;
+       struct winbindd_domain *domain;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct winbindd_change_machine_acct_state);
+       if (req == NULL) {
+               return NULL;
+       }
+
+       domain = find_domain_from_name(request->domain_name);
+       if (domain == NULL) {
+               tevent_req_nterror(req, NT_STATUS_NO_SUCH_DOMAIN);
+               return tevent_req_post(req, ev);
+       }
+       if (domain->internal) {
+               /*
+                * Internal domains are passdb based, we can always
+                * contact them.
+                */
+               tevent_req_done(req);
+               return tevent_req_post(req, ev);
+       }
+
+       subreq = rpccli_wbint_ChangeMachineAccount_send(state, ev,
+                                                       domain->child.rpccli);
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, winbindd_change_machine_acct_done, req);
+       return req;
+}
+
+static void winbindd_change_machine_acct_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct winbindd_change_machine_acct_state *state = tevent_req_data(
+               req, struct winbindd_change_machine_acct_state);
+       NTSTATUS status, result;
+
+       status = rpccli_wbint_ChangeMachineAccount_recv(subreq, state, &result);
+       if (!NT_STATUS_IS_OK(status)) {
+               tevent_req_nterror(req, status);
+               return;
+       }
+       if (!NT_STATUS_IS_OK(result)) {
+               tevent_req_nterror(req, result);
+               return;
+       }
+       tevent_req_done(req);
+}
+
+NTSTATUS winbindd_change_machine_acct_recv(struct tevent_req *req,
+                                          struct winbindd_response *presp)
+{
+       return tevent_req_simple_recv_ntstatus(req);
+}

diff --git a/source3/winbindd/winbindd_check_machine_acct.c b/source3/winbindd/winbindd_check_machine_acct.c
index e3505cb35238b593b87c87eadd86d16cd8e46cf7..610e9edfaaca30f72c2bdfc343f267892ee26070 100644 (file)
--- a/source3/winbindd/winbindd_check_machine_acct.c
+++ b/source3/winbindd/winbindd_check_machine_acct.c
@@ -42,7 +42,16 @@ struct tevent_req *winbindd_check_machine_acct_send(TALLOC_CTX *mem_ctx,
                return NULL;
        }
 
-       domain = find_our_domain();
+       if (request->domain_name[0] == '0') {
+               /* preserve old behavior, when no domain name is given */
+               domain = find_our_domain();
+       } else {
+               domain = find_domain_from_name(request->domain_name);
+       }
+       if (domain == NULL) {
+               tevent_req_nterror(req, NT_STATUS_NO_SUCH_DOMAIN);
+               return tevent_req_post(req, ev);
+       }
        if (domain->internal) {
                /*
                 * Internal domains are passdb based, we can always

diff --git a/source3/winbindd/winbindd_cm.c b/source3/winbindd/winbindd_cm.c
index 9a788397a99a78b5d10c61c1088071c186fe6ec6..95e1daf0b7183041f07c396b9bfcecb0a30aec88 100644 (file)
--- a/source3/winbindd/winbindd_cm.c
+++ b/source3/winbindd/winbindd_cm.c
@@ -2370,7 +2370,7 @@ NTSTATUS cm_connect_netlogon(struct winbindd_domain *domain,
 
        uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
        uint8  mach_pwd[16];
-       uint32  sec_chan_type;
+       enum netr_SchannelType sec_chan_type;
        const char *account_name;
        struct rpc_pipe_client *netlogon_pipe = NULL;
 

diff --git a/source3/winbindd/winbindd_dual.c b/source3/winbindd/winbindd_dual.c
index edf784cc210ddb466d7865c202e9e0016ed81530..a832451e0848e09a7c3b8e916a0f0fd429ce929a 100644 (file)
--- a/source3/winbindd/winbindd_dual.c
+++ b/source3/winbindd/winbindd_dual.c
@@ -1100,6 +1100,14 @@ static void machine_password_change_handler(struct event_context *ctx,
                DEBUG(10,("machine_password_change_handler: "
                        "failed to change machine password: %s\n",
                         nt_errstr(result)));
+               if (NT_STATUS_EQUAL(result, NT_STATUS_ACCESS_DENIED) ) {
+                       DEBUG(3,("machine_password_change_handler: password set returned "
+                               "ACCESS_DENIED.  Maybe the trust account "
+                               "password was changed and we didn't know it. "
+                               "Killing connections to domain %s\n",
+                               child->domain->name));
+                       invalidate_cm_connection(&child->domain->conn);
+               }
        } else {
                DEBUG(10,("machine_password_change_handler: "
                        "successfully changed machine password\n"));

diff --git a/source3/winbindd/winbindd_dual_srv.c b/source3/winbindd/winbindd_dual_srv.c
index 179a77106660c894fa929d33f344eaa636e2f6b7..f0bbee9f31871d98434ec61c48c4ae282c1fd150 100644 (file)
--- a/source3/winbindd/winbindd_dual_srv.c
+++ b/source3/winbindd/winbindd_dual_srv.c
@@ -4,6 +4,7 @@
    In-Child server implementation of the routines defined in wbint.idl
 
    Copyright (C) Volker Lendecke 2009
+   Copyright (C) Guenther Deschner 2009
 
    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
@@ -437,17 +438,78 @@ again:
        /* Pass back result code - zero for success, other values for
           specific failures. */
 
-       DEBUG(3, ("secret is %s\n", NT_STATUS_IS_OK(status) ?
-                  "good" : "bad"));
+       DEBUG(3,("domain %s secret is %s\n", domain->name,
+               NT_STATUS_IS_OK(status) ? "good" : "bad"));
 
  done:
        DEBUG(NT_STATUS_IS_OK(status) ? 5 : 2,
-             ("Checking the trust account password returned %s\n",
-              nt_errstr(status)));
+             ("Checking the trust account password for domain %s returned %s\n",
+              domain->name, nt_errstr(status)));
 
        return status;
 }
 
+NTSTATUS _wbint_ChangeMachineAccount(pipes_struct *p,
+                                    struct wbint_ChangeMachineAccount *r)
+{
+       struct winbindd_domain *domain;
+       int num_retries = 0;
+       NTSTATUS status;
+       struct rpc_pipe_client *netlogon_pipe;
+       TALLOC_CTX *tmp_ctx;
+
+again:
+       domain = wb_child_domain();
+       if (domain == NULL) {
+               return NT_STATUS_REQUEST_NOT_ACCEPTED;
+       }
+
+       invalidate_cm_connection(&domain->conn);
+
+       {
+               status = cm_connect_netlogon(domain, &netlogon_pipe);
+       }
+
+       /* There is a race condition between fetching the trust account
+          password and the periodic machine password change.  So it's
+          possible that the trust account password has been changed on us.
+          We are returned NT_STATUS_ACCESS_DENIED if this happens. */
+
+#define MAX_RETRIES 3
+
+       if ((num_retries < MAX_RETRIES)
+            && NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
+               num_retries++;
+               goto again;
+       }
+
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(3, ("could not open handle to NETLOGON pipe\n"));
+               goto done;
+       }
+
+       tmp_ctx = talloc_new(p->mem_ctx);
+
+       status = trust_pw_find_change_and_store_it(netlogon_pipe,
+                                                  tmp_ctx,
+                                                  domain->name);
+       talloc_destroy(tmp_ctx);
+
+       /* Pass back result code - zero for success, other values for
+          specific failures. */
+
+       DEBUG(3,("domain %s secret %s\n", domain->name,
+               NT_STATUS_IS_OK(status) ? "changed" : "unchanged"));
+
+ done:
+       DEBUG(NT_STATUS_IS_OK(status) ? 5 : 2,
+             ("Changing the trust account password for domain %s returned %s\n",
+              domain->name, nt_errstr(status)));
+
+       return status;
+}
+
+
 NTSTATUS _wbint_SetMapping(pipes_struct *p, struct wbint_SetMapping *r)
 {
        struct id_map map;

diff --git a/source3/winbindd/winbindd_pam.c b/source3/winbindd/winbindd_pam.c
index 178b3ea74be68c11f95a08580ad0359926f272ae..fe6485522e083f8ac1b32cb381b8c1f8a47105fe 100644 (file)
--- a/source3/winbindd/winbindd_pam.c
+++ b/source3/winbindd/winbindd_pam.c
@@ -797,8 +797,8 @@ NTSTATUS append_auth_data(struct winbindd_cli_state *state,
 void winbindd_pam_auth(struct winbindd_cli_state *state)
 {
        struct winbindd_domain *domain;
-       fstring name_domain, name_user;
-       char *mapped_user = NULL;
+       fstring name_domain, name_user, mapped_user;
+       char *mapped = NULL;
        NTSTATUS result;
        NTSTATUS name_map_status = NT_STATUS_UNSUCCESSFUL;
 
@@ -822,15 +822,16 @@ void winbindd_pam_auth(struct winbindd_cli_state *state)
 
        name_map_status = normalize_name_unmap(state->mem_ctx,
                                               state->request->data.auth.user,
-                                              &mapped_user);
+                                              &mapped);
 
        /* If the name normalization didnt' actually do anything,
           just use the original name */
 
-       if (!NT_STATUS_IS_OK(name_map_status) &&
-           !NT_STATUS_EQUAL(name_map_status, NT_STATUS_FILE_RENAMED))
-       {
-               mapped_user = state->request->data.auth.user;
+       if (NT_STATUS_IS_OK(name_map_status)
+           ||NT_STATUS_EQUAL(name_map_status, NT_STATUS_FILE_RENAMED)) {
+               fstrcpy(mapped_user, mapped);
+       } else {
+               fstrcpy(mapped_user, state->request->data.auth.user);
        }
 
        if (!canonicalize_username(mapped_user, name_domain, name_user)) {
@@ -2060,7 +2061,7 @@ enum winbindd_result winbindd_dual_pam_chauthtok(struct winbindd_domain *contact
        struct rpc_pipe_client *cli;
        bool got_info = false;
        struct samr_DomInfo1 *info = NULL;
-       struct samr_ChangeReject *reject = NULL;
+       struct userPwdChangeFailureInformation *reject = NULL;
        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
        fstring domain, user;
 
@@ -2102,7 +2103,7 @@ enum winbindd_result winbindd_dual_pam_chauthtok(struct winbindd_domain *contact
                fill_in_password_policy(state->response, info);
 
                state->response->data.auth.reject_reason =
-                       reject->reason;
+                       reject->extendedFailureReason;
 
                got_info = true;
        }

diff --git a/source3/winbindd/winbindd_proto.h b/source3/winbindd/winbindd_proto.h
index 307225877fd7f095bdff1ce6fd9ad0f36760725e..6e232c9db81aa62a3f0ab5618b019ffdde3e12d2 100644 (file)
--- a/source3/winbindd/winbindd_proto.h
+++ b/source3/winbindd/winbindd_proto.h
@@ -545,14 +545,6 @@ enum winbindd_result winbindd_dual_allocate_gid(struct winbindd_domain *domain,
 
 /* The following definitions come from winbindd/winbindd_user.c  */
 
-bool fillup_pw_field(const char *lp_template,
-                           const char *username,
-                           const char *domname,
-                           uid_t uid,
-                           gid_t gid,
-                           const char *in,
-                    fstring out);
-
 enum winbindd_result winbindd_dual_userinfo(struct winbindd_domain *domain,
                                            struct winbindd_cli_state *state);
 void winbindd_getpwnam(struct winbindd_cli_state *state);
@@ -995,6 +987,13 @@ struct tevent_req *winbindd_check_machine_acct_send(TALLOC_CTX *mem_ctx,
 NTSTATUS winbindd_check_machine_acct_recv(struct tevent_req *req,
                                          struct winbindd_response *presp);
 
+struct tevent_req *winbindd_change_machine_acct_send(TALLOC_CTX *mem_ctx,
+                                                    struct tevent_context *ev,
+                                                    struct winbindd_cli_state *cli,
+                                                    struct winbindd_request *request);
+NTSTATUS winbindd_change_machine_acct_recv(struct tevent_req *req,
+                                          struct winbindd_response *presp);
+
 struct tevent_req *winbindd_set_mapping_send(TALLOC_CTX *mem_ctx,
                                             struct tevent_context *ev,
                                             struct winbindd_cli_state *cli,

diff --git a/source3/winbindd/winbindd_rpc.c b/source3/winbindd/winbindd_rpc.c
index ac5c3d2d93a66339406c82b8c97c68fa63e26373..ce437f744cafb7aa882d35ab1a426ab5251623ad 100644 (file)
--- a/source3/winbindd/winbindd_rpc.c
+++ b/source3/winbindd/winbindd_rpc.c
@@ -99,14 +99,19 @@ static NTSTATUS query_user_list(struct winbindd_domain *domain,
                for (j = 0; j < num_dom_users; i++, j++) {
 
                        uint32_t rid = disp_info.info1.entries[j].rid;
+                       struct samr_DispEntryGeneral *src;
+                       struct wbint_userinfo *dst;
 
-                       (*info)[i].acct_name = talloc_strdup(mem_ctx,
-                               disp_info.info1.entries[j].account_name.string);
-                       (*info)[i].full_name = talloc_strdup(mem_ctx,
-                               disp_info.info1.entries[j].full_name.string);
-                       (*info)[i].homedir = NULL;
-                       (*info)[i].shell = NULL;
-                       sid_compose(&(*info)[i].user_sid, &domain->sid, rid);
+                       src = &(disp_info.info1.entries[j]);
+                       dst = &((*info)[i]);
+
+                       dst->acct_name = talloc_strdup(
+                               mem_ctx, src->account_name.string);
+                       dst->full_name = talloc_strdup(
+                               mem_ctx, src->full_name.string);
+                       dst->homedir = NULL;
+                       dst->shell = NULL;
+                       sid_compose(&dst->user_sid, &domain->sid, rid);
 
                        /* For the moment we set the primary group for
                           every user to be the Domain Users group.
@@ -116,7 +121,7 @@ static NTSTATUS query_user_list(struct winbindd_domain *domain,
                           force group' smb.conf parameter or
                           something like that. */
 
-                       sid_compose(&(*info)[i].group_sid, &domain->sid, 
+                       sid_compose(&dst->group_sid, &domain->sid,
                                    DOMAIN_GROUP_RID_USERS);
                }
 

diff --git a/source3/winbindd/winbindd_user.c b/source3/winbindd/winbindd_user.c
index b23b7df608c81c5d7d40e0223f5701dac947b787..6afa941b7f5c207f30a6dfd168f83814d755d58f 100644 (file)
--- a/source3/winbindd/winbindd_user.c
+++ b/source3/winbindd/winbindd_user.c
@@ -27,45 +27,6 @@
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_WINBIND
 
-bool fillup_pw_field(const char *lp_template,
-                           const char *username,
-                           const char *domname,
-                           uid_t uid,
-                           gid_t gid,
-                           const char *in,
-                           fstring out)
-{
-       char *templ;
-
-       if (out == NULL)
-               return False;
-
-       /* The substitution of %U and %D in the 'template
-          homedir' is done by talloc_sub_specified() below.
-          If we have an in string (which means the value has already
-          been set in the nss_info backend), then use that.
-          Otherwise use the template value passed in. */
-
-       if ( in && !strequal(in,"") && lp_security() == SEC_ADS ) {
-               templ = talloc_sub_specified(NULL, in,
-                                            username, domname,
-                                    uid, gid);
-       } else {
-               templ = talloc_sub_specified(NULL, lp_template,
-                                            username, domname,
-                                            uid, gid);
-       }
-
-       if (!templ)
-               return False;
-
-       safe_strcpy(out, templ, sizeof(fstring) - 1);
-       TALLOC_FREE(templ);
-
-       return True;
-
-}
-
 /* Wrapper for domain->methods->query_user, only on the parent->child pipe */
 
 enum winbindd_result winbindd_dual_userinfo(struct winbindd_domain *domain,

diff --git a/source4/auth/credentials/credentials.c b/source4/auth/credentials/credentials.c
index 83901db6a559d62cd65f5fa8fa9f37ae0f04f93d..549c2691f0301f246b125eda0a79722a905968fe 100644 (file)
--- a/source4/auth/credentials/credentials.c
+++ b/source4/auth/credentials/credentials.c
@@ -37,12 +37,10 @@
 _PUBLIC_ struct cli_credentials *cli_credentials_init(TALLOC_CTX *mem_ctx) 
 {
        struct cli_credentials *cred = talloc(mem_ctx, struct cli_credentials);
-       if (!cred) {
+       if (cred == NULL) {
                return cred;
        }
 
-       cred->netlogon_creds = NULL;
-       cred->machine_account_pending = false;
        cred->workstation_obtained = CRED_UNINITIALISED;
        cred->username_obtained = CRED_UNINITIALISED;
        cred->password_obtained = CRED_UNINITIALISED;
@@ -50,21 +48,51 @@ _PUBLIC_ struct cli_credentials *cli_credentials_init(TALLOC_CTX *mem_ctx)
        cred->realm_obtained = CRED_UNINITIALISED;
        cred->ccache_obtained = CRED_UNINITIALISED;
        cred->client_gss_creds_obtained = CRED_UNINITIALISED;
-       cred->server_gss_creds_obtained = CRED_UNINITIALISED;
-       cred->keytab_obtained = CRED_UNINITIALISED;
        cred->principal_obtained = CRED_UNINITIALISED;
+       cred->keytab_obtained = CRED_UNINITIALISED;
+       cred->server_gss_creds_obtained = CRED_UNINITIALISED;
 
        cred->ccache_threshold = CRED_UNINITIALISED;
        cred->client_gss_creds_threshold = CRED_UNINITIALISED;
 
+       cred->workstation = NULL;
+       cred->username = NULL;
+       cred->password = NULL;
        cred->old_password = NULL;
-       cred->smb_krb5_context = NULL;
+       cred->domain = NULL;
+       cred->realm = NULL;
+       cred->principal = NULL;
        cred->salt_principal = NULL;
-       cred->machine_account = false;
 
        cred->bind_dn = NULL;
 
+       cred->nt_hash = NULL;
+
+       cred->ccache = NULL;
+       cred->client_gss_creds = NULL;
+       cred->keytab = NULL;
+       cred->server_gss_creds = NULL;
+
+       cred->workstation_cb = NULL;
+       cred->password_cb = NULL;
+       cred->username_cb = NULL;
+       cred->domain_cb = NULL;
+       cred->realm_cb = NULL;
+       cred->principal_cb = NULL;
+
+       cred->priv_data = NULL;
+
+       cred->netlogon_creds = NULL;
+
+       cred->smb_krb5_context = NULL;
+
+       cred->machine_account_pending = false;
+       cred->machine_account_pending_lp_ctx = NULL;
+
+       cred->machine_account = false;
+
        cred->tries = 3;
+
        cred->callback_running = false;
 
        cli_credentials_set_kerberos_state(cred, CRED_AUTO_USE_KERBEROS);
@@ -722,6 +750,11 @@ _PUBLIC_ bool cli_credentials_is_anonymous(struct cli_credentials *cred)
 {
        const char *username;
        
+       /* if bind dn is set it's not anonymous */
+       if (cred->bind_dn) {
+               return false;
+       }
+
        if (cred->machine_account_pending) {
                cli_credentials_set_machine_account(cred,
                                                    cred->machine_account_pending_lp_ctx);

diff --git a/source4/auth/credentials/credentials_files.c b/source4/auth/credentials/credentials_files.c
index 3fe38d5cd162e608421bbd41a9d29b49be1722c8..42e8ea082ad50d6d8362719fd671363029230bb2 100644 (file)
--- a/source4/auth/credentials/credentials_files.c
+++ b/source4/auth/credentials/credentials_files.c
@@ -266,6 +266,9 @@ _PUBLIC_ NTSTATUS cli_credentials_set_secrets(struct cli_credentials *cred,
                                cli_credentials_set_anonymous(cred);
                                talloc_free(mem_ctx);
                                return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
+                       } else {
+                               /* store bind dn in credentials */
+                               cli_credentials_set_bind_dn(cred, ldap_bind_dn);
                        }
                }
        }

diff --git a/source4/auth/gensec/config.mk b/source4/auth/gensec/config.mk
index 65f5208e1ab13dc334f6614162ea9d7ed858e45a..aa52b184fca3e82dfed7bc2f2a0284c6dd71784e 100644 (file)
--- a/source4/auth/gensec/config.mk
+++ b/source4/auth/gensec/config.mk
@@ -86,7 +86,7 @@ SCHANNELDB_OBJ_FILES = $(addprefix $(gensecsrcdir)/, schannel_state.o)
 $(eval $(call proto_header_template,$(gensecsrcdir)/schannel_state.h,$(SCHANNELDB_OBJ_FILES:.o=.c)))
 
 [PYTHON::pygensec]
-PRIVATE_DEPENDENCIES = gensec PYTALLOC
+PRIVATE_DEPENDENCIES = gensec PYTALLOC pyparam_util
 LIBRARY_REALNAME = samba/gensec.$(SHLIBEXT)
 
 pygensec_OBJ_FILES = $(gensecsrcdir)/pygensec.o

diff --git a/source4/auth/gensec/gensec_gssapi.c b/source4/auth/gensec/gensec_gssapi.c
index a23f913264b1b030513c25c3a7e2f879bf9b173d..2759ab41c3062c07b0d14cdbb86590af169a16b6 100644 (file)
--- a/source4/auth/gensec/gensec_gssapi.c
+++ b/source4/auth/gensec/gensec_gssapi.c
@@ -147,6 +147,7 @@ static NTSTATUS gensec_gssapi_start(struct gensec_security *gensec_security)
        struct gensec_gssapi_state *gensec_gssapi_state;
        krb5_error_code ret;
        struct gsskrb5_send_to_kdc send_to_kdc;
+       const char *realm;
 
        gensec_gssapi_state = talloc(gensec_security, struct gensec_gssapi_state);
        if (!gensec_gssapi_state) {
@@ -226,15 +227,10 @@ static NTSTATUS gensec_gssapi_start(struct gensec_security *gensec_security)
                talloc_free(gensec_gssapi_state);
                return NT_STATUS_INTERNAL_ERROR;
        }
-       if (lp_realm(gensec_security->settings->lp_ctx) && *lp_realm(gensec_security->settings->lp_ctx)) {
-               char *upper_realm = strupper_talloc(gensec_gssapi_state, lp_realm(gensec_security->settings->lp_ctx));
-               if (!upper_realm) {
-                       DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm(gensec_security->settings->lp_ctx)));
-                       talloc_free(gensec_gssapi_state);
-                       return NT_STATUS_NO_MEMORY;
-               }
-               ret = gsskrb5_set_default_realm(upper_realm);
-               talloc_free(upper_realm);
+
+       realm = lp_realm(gensec_security->settings->lp_ctx);
+       if (realm != NULL) {
+               ret = gsskrb5_set_default_realm(realm);
                if (ret) {
                        DEBUG(1,("gensec_krb5_start: gsskrb5_set_default_realm failed\n"));
                        talloc_free(gensec_gssapi_state);

diff --git a/source4/auth/gensec/pygensec.c b/source4/auth/gensec/pygensec.c
index efa97e0184a914c094137c4580673b1b99a82315..d6d1f63ef1da5e88de74d56bc2f347032f3ecf32 100644 (file)
--- a/source4/auth/gensec/pygensec.c
+++ b/source4/auth/gensec/pygensec.c
@@ -19,8 +19,10 @@
 #include "includes.h"
 #include <Python.h>
 #include "param/param.h"
+#include "param/pyparam.h"
 #include "auth/gensec/gensec.h"
 #include "libcli/util/pyerrors.h"
+#include "scripting/python/modules.h"
 #include "pytalloc.h"
 #include <tevent.h>
 
@@ -46,9 +48,35 @@ static PyObject *py_get_name_by_authtype(PyObject *self, PyObject *args)
        return PyString_FromString(name);
 }
 
-static struct gensec_settings *settings_from_object(PyObject *object)
+static struct gensec_settings *settings_from_object(TALLOC_CTX *mem_ctx, PyObject *object)
 {
-       return NULL; /* FIXME */
+       struct gensec_settings *s;
+       PyObject *py_hostname, *py_lp_ctx;
+
+       if (!PyDict_Check(object)) {
+               PyErr_SetString(PyExc_ValueError, "settings should be a dictionary");
+               return NULL;
+       }
+
+       s = talloc_zero(mem_ctx, struct gensec_settings);
+       if (!s) return NULL;
+
+       py_hostname = PyDict_GetItemString(object, "target_hostname");
+       if (!py_hostname) {
+               PyErr_SetString(PyExc_ValueError, "settings.target_hostname not found");
+               return NULL;
+       }
+
+       py_lp_ctx = PyDict_GetItemString(object, "lp_ctx");
+       if (!py_lp_ctx) {
+               PyErr_SetString(PyExc_ValueError, "settings.lp_ctx not found");
+               return NULL;
+       }
+       
+       s->target_hostname = PyString_AsString(py_hostname);
+       s->lp_ctx = lp_from_py_object(py_lp_ctx);
+       s->iconv_convenience = py_iconv_convenience(s);
+       return s;
 }
 
 static PyObject *py_gensec_start_client(PyTypeObject *type, PyObject *args, PyObject *kwargs)
@@ -60,13 +88,9 @@ static PyObject *py_gensec_start_client(PyTypeObject *type, PyObject *args, PyOb
        PyObject *py_settings;
        struct tevent_context *ev;
 
-       if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", kwnames, &py_settings))
+       if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", discard_const_p(char *, kwnames), &py_settings))
                return NULL;
 
-       settings = settings_from_object(py_settings);
-       if (settings == NULL)
-               return NULL;
-       
        self = (py_talloc_Object*)type->tp_alloc(type, 0);
        if (self == NULL) {
                PyErr_NoMemory();
@@ -77,12 +101,27 @@ static PyObject *py_gensec_start_client(PyTypeObject *type, PyObject *args, PyOb
                PyErr_NoMemory();
                return NULL;
        }
+
+       settings = settings_from_object(self->talloc_ctx, py_settings);
+       if (settings == NULL) {
+               PyObject_DEL(self);
+               return NULL;
+       }
+       
        ev = tevent_context_init(self->talloc_ctx);
        if (ev == NULL) {
                PyErr_NoMemory();
                PyObject_Del(self);
                return NULL;
        }
+
+       status = gensec_init(settings->lp_ctx);
+       if (!NT_STATUS_IS_OK(status)) {
+               PyErr_SetNTSTATUS(status);
+               PyObject_DEL(self);
+               return NULL;
+       }
+
        status = gensec_client_start(self->talloc_ctx, 
                (struct gensec_security **)&self->ptr, ev, settings);
        if (!NT_STATUS_IS_OK(status)) {
@@ -98,6 +137,10 @@ static PyObject *py_gensec_session_info(PyObject *self)
        NTSTATUS status;
        struct gensec_security *security = (struct gensec_security *)py_talloc_get_ptr(self);
        struct auth_session_info *info;
+       if (security->ops == NULL) {
+               PyErr_SetString(PyExc_ValueError, "gensec not fully initialised - ask Andrew");
+               return NULL;
+       }
        status = gensec_session_info(security, &info);
        if (NT_STATUS_IS_ERR(status)) {
                PyErr_SetNTSTATUS(status);

diff --git a/source4/auth/gensec/tests/bindings.py b/source4/auth/gensec/tests/bindings.py
index 95d7833e4a07cfcd47db2cd037feed3fd7d069e2..f88fa82ae1b84099d9b2606af6f28bada73811a6 100644 (file)
--- a/source4/auth/gensec/tests/bindings.py
+++ b/source4/auth/gensec/tests/bindings.py
@@ -25,11 +25,15 @@ the functionality, that's already done in other tests.
 
 import unittest
 from samba import gensec
+from samba.tests import cmdline_loadparm
 
 class CredentialsTests(unittest.TestCase):
 
     def setUp(self):
-        self.gensec = gensec.Security.start_client()
+        settings = {}
+        settings["target_hostname"] = "localhost"
+        settings["lp_ctx"] = cmdline_loadparm
+        self.gensec = gensec.Security.start_client(settings)
 
     def test_info(self):
         self.assertEquals(None, self.gensec.session_info())

diff --git a/source4/auth/kerberos/krb5_init_context.c b/source4/auth/kerberos/krb5_init_context.c
index 04f0718a62eca73fd77e4de552916edee9161532..c00d7b16182bc03b010adbc5f14a2ddc3b818af5 100644 (file)
--- a/source4/auth/kerberos/krb5_init_context.c
+++ b/source4/auth/kerberos/krb5_init_context.c
@@ -368,7 +368,7 @@ krb5_error_code smb_krb5_init_context(void *parent_ctx,
        krb5_error_code ret;
        TALLOC_CTX *tmp_ctx;
        char **config_files;
-       const char *config_file;
+       const char *config_file, *realm;
        
        initialize_krb5_error_table();
        
@@ -415,14 +415,9 @@ krb5_error_code smb_krb5_init_context(void *parent_ctx,
                return ret;
        }
                                                
-       if (lp_realm(lp_ctx) && *lp_realm(lp_ctx)) {
-               char *upper_realm = strupper_talloc(tmp_ctx, lp_realm(lp_ctx));
-               if (!upper_realm) {
-                       DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm(lp_ctx)));
-                       talloc_free(tmp_ctx);
-                       return ENOMEM;
-               }
-               ret = krb5_set_default_realm((*smb_krb5_context)->krb5_context, upper_realm);
+       realm = lp_realm(lp_ctx);
+       if (realm != NULL) {
+               ret = krb5_set_default_realm((*smb_krb5_context)->krb5_context, realm);
                if (ret) {
                        DEBUG(1,("krb5_set_default_realm failed (%s)\n", 
                                 smb_get_krb5_error_message((*smb_krb5_context)->krb5_context, ret, tmp_ctx)));

diff --git a/source4/auth/ntlm/auth_sam.c b/source4/auth/ntlm/auth_sam.c
index a64c56d920f276064d01d39d92e6c68fb480cbf8..58a21d2d22bae2cf22ea27b2a8990bb436897f4d 100644 (file)
--- a/source4/auth/ntlm/auth_sam.c
+++ b/source4/auth/ntlm/auth_sam.c
@@ -332,6 +332,7 @@ NTSTATUS authsam_get_server_info_principal(TALLOC_CTX *mem_ctx,
        nt_status = sam_get_results_principal(sam_ctx, tmp_ctx, principal, 
                                              user_attrs, &domain_dn, &msg);
        if (!NT_STATUS_IS_OK(nt_status)) {
+               talloc_free(tmp_ctx);
                return nt_status;
        }
 
@@ -342,11 +343,15 @@ NTSTATUS authsam_get_server_info_principal(TALLOC_CTX *mem_ctx,
                                             msg,
                                             user_sess_key, lm_sess_key,
                                             server_info);
-       if (NT_STATUS_IS_OK(nt_status)) {
-               talloc_steal(mem_ctx, *server_info);
+       if (!NT_STATUS_IS_OK(nt_status)) {
+               talloc_free(tmp_ctx);
+               return nt_status;
        }
+
+       talloc_steal(mem_ctx, *server_info);
        talloc_free(tmp_ctx);
-       return nt_status;
+
+       return NT_STATUS_OK;
 }
 
 static const struct auth_operations sam_ignoredomain_ops = {

diff --git a/source4/auth/ntlmssp/ntlmssp_server.c b/source4/auth/ntlmssp/ntlmssp_server.c
index b55c1cd930021d4f93e5a4ec69ce53bc507c390f..a56b21a1a28bbc8d67941f664b5dae765b09f90f 100644 (file)
--- a/source4/auth/ntlmssp/ntlmssp_server.c
+++ b/source4/auth/ntlmssp/ntlmssp_server.c
@@ -186,8 +186,7 @@ NTSTATUS ntlmssp_server_negotiate(struct gensec_security *gensec_security,
 
                /* Find out the DNS domain name */
                dnsdomname[0] = '\0';
-               safe_strcpy(dnsdomname, lp_realm(gensec_security->settings->lp_ctx), sizeof(dnsdomname) - 1);
-               strlower_m(dnsdomname);
+               safe_strcpy(dnsdomname, lp_dnsdomain(gensec_security->settings->lp_ctx), sizeof(dnsdomname) - 1);
 
                /* Find out the DNS host name */
                safe_strcpy(dnsname, gensec_ntlmssp_state->server_name, sizeof(dnsname) - 1);

diff --git a/source4/cldap_server/netlogon.c b/source4/cldap_server/netlogon.c
index ecc1369dcf99b408bee02a31bb71a3c03358b673..b06fd609f29239bc5a7da767dfc96f767b742860 100644 (file)
--- a/source4/cldap_server/netlogon.c
+++ b/source4/cldap_server/netlogon.c
@@ -61,7 +61,6 @@ NTSTATUS fill_netlogon_samlogon_response(struct ldb_context *sam_ctx,
        uint32_t server_type;
        const char *pdc_name;
        struct GUID domain_uuid;
-       const char *realm;
        const char *dns_domain;
        const char *pdc_dns_name;
        const char *flatname;
@@ -78,7 +77,7 @@ NTSTATUS fill_netlogon_samlogon_response(struct ldb_context *sam_ctx,
                domain = talloc_strndup(mem_ctx, domain, strlen(domain)-1);
        }
 
-       if (domain && strcasecmp_m(domain, lp_realm(lp_ctx)) == 0) {
+       if (domain && strcasecmp_m(domain, lp_dnsdomain(lp_ctx)) == 0) {
                domain_dn = ldb_get_default_basedn(sam_ctx);
        }
 
@@ -206,40 +205,46 @@ NTSTATUS fill_netlogon_samlogon_response(struct ldb_context *sam_ctx,
        }
                
        server_type      = 
-               NBT_SERVER_DS | NBT_SERVER_TIMESERV |
-               NBT_SERVER_CLOSEST | NBT_SERVER_WRITABLE | 
-               NBT_SERVER_GOOD_TIMESERV | DS_DNS_CONTROLLER |
-               DS_DNS_DOMAIN;
+               DS_SERVER_DS | DS_SERVER_TIMESERV |
+               DS_SERVER_CLOSEST | DS_SERVER_WRITABLE | 
+               DS_SERVER_GOOD_TIMESERV;
+
+#if 0
+       /* w2k8-r2 as a DC does not claim these */
+       server_type |= DS_DNS_CONTROLLER | DS_DNS_DOMAIN;
+#endif
 
        if (samdb_is_pdc(sam_ctx)) {
                int *domainFunctionality;
-               server_type |= NBT_SERVER_PDC;
+               server_type |= DS_SERVER_PDC;
                domainFunctionality = talloc_get_type(ldb_get_opaque(sam_ctx, "domainFunctionality"), int);
                if (domainFunctionality && *domainFunctionality >= DS_DOMAIN_FUNCTION_2008) {
-                       server_type |= NBT_SERVER_FULL_SECRET_DOMAIN_6;
+                       server_type |= DS_SERVER_FULL_SECRET_DOMAIN_6;
                }
        }
 
        if (samdb_is_gc(sam_ctx)) {
-               server_type |= NBT_SERVER_GC;
+               server_type |= DS_SERVER_GC;
        }
 
        if (str_list_check(services, "ldap")) {
-               server_type |= NBT_SERVER_LDAP;
+               server_type |= DS_SERVER_LDAP;
        }
 
        if (str_list_check(services, "kdc")) {
-               server_type |= NBT_SERVER_KDC;
+               server_type |= DS_SERVER_KDC;
        }
 
+#if 0
+       /* w2k8-r2 as a sole DC does not claim this */
        if (ldb_dn_compare(ldb_get_root_basedn(sam_ctx), ldb_get_default_basedn(sam_ctx)) == 0) {
-               server_type |= DS_DNS_FOREST;
+               server_type |= DS_DNS_FOREST_ROOT;
        }
+#endif
 
        pdc_name         = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name(lp_ctx));
        domain_uuid      = samdb_result_guid(dom_res->msgs[0], "objectGUID");
-       realm            = lp_realm(lp_ctx);
-       dns_domain       = lp_realm(lp_ctx);
+       dns_domain       = lp_dnsdomain(lp_ctx);
        pdc_dns_name     = talloc_asprintf(mem_ctx, "%s.%s", 
                                           strlower_talloc(mem_ctx, 
                                                           lp_netbios_name(lp_ctx)), 
@@ -267,7 +272,7 @@ NTSTATUS fill_netlogon_samlogon_response(struct ldb_context *sam_ctx,
                }
                netlogon->data.nt5_ex.server_type  = server_type;
                netlogon->data.nt5_ex.domain_uuid  = domain_uuid;
-               netlogon->data.nt5_ex.forest       = realm;
+               netlogon->data.nt5_ex.forest       = dns_domain;
                netlogon->data.nt5_ex.dns_domain   = dns_domain;
                netlogon->data.nt5_ex.pdc_dns_name = pdc_dns_name;
                netlogon->data.nt5_ex.domain       = flatname;
@@ -300,7 +305,7 @@ NTSTATUS fill_netlogon_samlogon_response(struct ldb_context *sam_ctx,
                netlogon->data.nt5.user_name    = user;
                netlogon->data.nt5.domain_name  = flatname;
                netlogon->data.nt5.domain_uuid  = domain_uuid;
-               netlogon->data.nt5.forest       = realm;
+               netlogon->data.nt5.forest       = dns_domain;
                netlogon->data.nt5.dns_domain   = dns_domain;
                netlogon->data.nt5.pdc_dns_name = pdc_dns_name;
                netlogon->data.nt5.pdc_ip       = pdc_ip;
@@ -396,7 +401,7 @@ void cldapd_netlogon_request(struct cldap_socket *cldap,
        }
 
        if (domain_guid == NULL && domain == NULL) {
-               domain = lp_realm(cldapd->task->lp_ctx);
+               domain = lp_dnsdomain(cldapd->task->lp_ctx);
        }
 
        if (version == -1) {

diff --git a/source4/client/client.c b/source4/client/client.c
index 3fa819c8e7f1f17669bad6969dac1bc350a0649a..c1292a2befee486b484aa4d42cf9f075c0fe251c 100644 (file)
--- a/source4/client/client.c
+++ b/source4/client/client.c
@@ -264,9 +264,9 @@ static int do_cd(struct smbclient_context *ctx, const char *newdir)
        /* Save the current directory in case the
           new directory is invalid */
        if (newdir[0] == '\\')
-               dname = talloc_strdup(NULL, newdir);
+               dname = talloc_strdup(ctx, newdir);
        else
-               dname = talloc_asprintf(NULL, "%s\\%s", ctx->remote_cur_dir, newdir);
+               dname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, newdir);
 
        dos_format(dname);
 
@@ -685,7 +685,7 @@ static int cmd_du(struct smbclient_context *ctx, const char **args)
 /****************************************************************************
   get a file from rname to lname
   ****************************************************************************/
-static int do_get(struct smbclient_context *ctx, char *rname, const char *lname, bool reget)
+static int do_get(struct smbclient_context *ctx, char *rname, const char *p_lname, bool reget)
 {  
        int handle = 0, fnum;
        bool newhandle = false;
@@ -697,11 +697,14 @@ static int do_get(struct smbclient_context *ctx, char *rname, const char *lname,
        off_t start = 0;
        off_t nread = 0;
        int rc = 0;
+       char *lname;
+
 
+       lname = talloc_strdup(ctx, p_lname);
        GetTimeOfDay(&tp_start);
 
        if (ctx->lowercase) {
-               strlower(discard_const_p(char, lname));
+               strlower(lname);
        }
 
        fnum = smbcli_open(ctx->cli->tree, rname, O_RDONLY, DENY_NONE);
@@ -858,6 +861,7 @@ static void do_mget(struct smbclient_context *ctx, struct clilist_file_info *fin
        char *quest;
        char *mget_mask;
        char *saved_curdir;
+       char *l_fname;
 
        if (ISDOT(finfo->name) || ISDOTDOT(finfo->name))
                return;
@@ -879,27 +883,29 @@ static void do_mget(struct smbclient_context *ctx, struct clilist_file_info *fin
        }
 
        /* handle directories */
-       saved_curdir = talloc_strdup(NULL, ctx->remote_cur_dir);
+       saved_curdir = talloc_strdup(ctx, ctx->remote_cur_dir);
 
        ctx->remote_cur_dir = talloc_asprintf_append_buffer(NULL, "%s\\", finfo->name);
 
-       string_replace(discard_const_p(char, finfo->name), '\\', '/');
+       l_fname = talloc_strdup(ctx, finfo->name);
+
+       string_replace(l_fname, '\\', '/');
        if (ctx->lowercase) {
-               strlower(discard_const_p(char, finfo->name));
+               strlower(l_fname);
        }
        
-       if (!directory_exist(finfo->name) && 
-           mkdir(finfo->name,0777) != 0) {
-               d_printf("failed to create directory %s\n",finfo->name);
+       if (!directory_exist(l_fname) &&
+           mkdir(l_fname, 0777) != 0) {
+               d_printf("failed to create directory %s\n", l_fname);
                return;
        }
        
-       if (chdir(finfo->name) != 0) {
-               d_printf("failed to chdir to directory %s\n",finfo->name);
+       if (chdir(l_fname) != 0) {
+               d_printf("failed to chdir to directory %s\n", l_fname);
                return;
        }
 
-       mget_mask = talloc_asprintf(NULL, "%s*", ctx->remote_cur_dir);
+       mget_mask = talloc_asprintf(ctx, "%s*", ctx->remote_cur_dir);
        
        do_list(ctx, mget_mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,do_mget,false, true);
        chdir("..");
@@ -963,7 +969,7 @@ static int cmd_mget(struct smbclient_context *ctx, const char **args)
                attribute |= FILE_ATTRIBUTE_DIRECTORY;
        
        for (i = 1; args[i]; i++) {
-               mget_mask = talloc_strdup(ctx,ctx->remote_cur_dir);
+               mget_mask = talloc_strdup(ctx, ctx->remote_cur_dir);
                if(mget_mask[strlen(mget_mask)-1]!='\\')
                        mget_mask = talloc_append_string(ctx, mget_mask, "\\");
                
@@ -1292,7 +1298,7 @@ static bool seek_list(struct file_list *list, char *name)
 static int cmd_select(struct smbclient_context *ctx, const char **args)
 {
        talloc_free(ctx->fileselection);
-       ctx->fileselection = talloc_strdup(NULL, args[1]);
+       ctx->fileselection = talloc_strdup(ctx, args[1]);
 
        return 0;
 }
@@ -1533,7 +1539,7 @@ static int cmd_del(struct smbclient_context *ctx, const char **args)
                d_printf("del <filename>\n");
                return 1;
        }
-       mask = talloc_asprintf(ctx,"%s%s", ctx->remote_cur_dir, args[1]);
+       mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
 
        if (NT_STATUS_IS_ERR(smbcli_unlink(ctx->cli->tree, mask))) {
                d_printf("%s deleting remote file %s\n",smbcli_errstr(ctx->cli->tree),mask);
@@ -2994,7 +3000,7 @@ static int process_line(struct smbclient_context *ctx, const char *cline)
        int i;
 
        /* and get the first part of the command */
-       args = str_list_make_shell(ctx, cline, NULL);
+       args = (const char **) str_list_make_shell(ctx, cline, NULL);
        if (!args || !args[0])
                return 0;
 
@@ -3151,12 +3157,12 @@ static int do_message_op(const char *netbios_name, const char *desthost,
 ****************************************************************************/
  int main(int argc,char *argv[])
 {
-       const char *base_directory = NULL;
+       char *base_directory = NULL;
        const char *dest_ip = NULL;
        int opt;
        const char *query_host = NULL;
        bool message = false;
-       const char *desthost = NULL;
+       char *desthost = NULL;
        poptContext pc;
        const char *service = NULL;
        int port = 0;

diff --git a/source4/dsdb/common/sidmap.c b/source4/dsdb/common/sidmap.c
deleted file mode 100644 (file)
index 3111a78..0000000
--- a/source4/dsdb/common/sidmap.c
+++ /dev/null
@@ -1,612 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-
-   mapping routines for SID <-> unix uid/gid
-
-   Copyright (C) Andrew Tridgell 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/>.
-*/
-
-#include "includes.h"
-#include "system/passwd.h"
-#include "../libds/common/flags.h"
-#include "dsdb/samdb/samdb.h"
-#include "auth/auth.h"
-#include "libcli/ldap/ldap_ndr.h"
-#include "lib/ldb/include/ldb.h"
-#include "../lib/util/util_ldb.h"
-#include "libcli/security/security.h"
-#include "param/param.h"
-
-/*
-  these are used for the fallback local uid/gid to sid mapping
-  code.
-*/
-#define SIDMAP_LOCAL_USER_BASE  0x80000000
-#define SIDMAP_LOCAL_GROUP_BASE 0xC0000000
-#define SIDMAP_MAX_LOCAL_UID    0x3fffffff
-#define SIDMAP_MAX_LOCAL_GID    0x3fffffff
-
-/*
-  private context for sid mapping routines
-*/
-struct sidmap_context {
-       struct ldb_context *samctx;
-};
-
-/*
-  open a sidmap context - use talloc_free to close
-*/
-struct sidmap_context *sidmap_open(TALLOC_CTX *mem_ctx, struct tevent_context *ev_ctx, 
-                                  struct loadparm_context *lp_ctx)
-{
-       struct sidmap_context *sidmap;
-       sidmap = talloc(mem_ctx, struct sidmap_context);
-       if (sidmap == NULL) {
-               return NULL;
-       }
-       sidmap->samctx = samdb_connect(sidmap, ev_ctx, lp_ctx, system_session(sidmap, lp_ctx));
-       if (sidmap->samctx == NULL) {
-               talloc_free(sidmap);
-               return NULL;
-       }
-
-       return sidmap;
-}
-
-
-/*
-  check the sAMAccountType field of a search result to see if
-  the account is a user account
-*/
-static bool is_user_account(struct ldb_message *res)
-{
-       uint_t atype = samdb_result_uint(res, "sAMAccountType", 0);
-       if (atype && (!(atype & ATYPE_ACCOUNT))) {
-               return false;
-       }
-       return true;
-}
-
-/*
-  check the sAMAccountType field of a search result to see if
-  the account is a group account
-*/
-static bool is_group_account(struct ldb_message *res)
-{
-       uint_t atype = samdb_result_uint(res, "sAMAccountType", 0);
-       if (atype && atype == ATYPE_NORMAL_ACCOUNT) {
-               return false;
-       }
-       return true;
-}
-
-
-
-/*
-  return the dom_sid of our primary domain
-*/
-static NTSTATUS sidmap_primary_domain_sid(struct sidmap_context *sidmap, 
-                                         TALLOC_CTX *mem_ctx, struct dom_sid **sid)
-{
-       const char *attrs[] = { "objectSid", NULL };
-       int ret;
-       struct ldb_message **res = NULL;
-
-       ret = gendb_search_dn(sidmap->samctx, mem_ctx, NULL, &res, attrs);
-       if (ret != 1) {
-               talloc_free(res);
-               return NT_STATUS_NO_SUCH_DOMAIN;
-       }
-       
-       *sid = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
-       talloc_free(res);
-       if (*sid == NULL) {
-               return NT_STATUS_NO_MEMORY;
-       }
-
-       return NT_STATUS_OK;
-}
-
-
-/*
-  map a sid to a unix uid
-*/
-NTSTATUS sidmap_sid_to_unixuid(struct sidmap_context *sidmap,
-                                       const struct dom_sid *sid, uid_t *uid)
-{
-       const char *attrs[] = { "sAMAccountName", "uidNumber",
-                               "sAMAccountType", "unixName", NULL };
-       int ret;
-       const char *s;
-       TALLOC_CTX *tmp_ctx;
-       struct ldb_message **res;
-       struct dom_sid *domain_sid;
-       NTSTATUS status;
-
-       tmp_ctx = talloc_new(sidmap);
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs,
-                          "objectSid=%s",
-                          ldap_encode_ndr_dom_sid(tmp_ctx, sid));
-
-       if (ret != 1) {
-               goto allocated_sid;
-       }
-
-       /* make sure its a user, not a group */
-       if (!is_user_account(res[0])) {
-               DEBUG(0,("sid_to_unixuid: sid %s is not an account!\n",
-                        dom_sid_string(tmp_ctx, sid)));
-               talloc_free(tmp_ctx);
-               return NT_STATUS_INVALID_SID;
-       }
-
-       /* first try to get the uid directly */
-       s = samdb_result_string(res[0], "uidNumber", NULL);
-       if (s != NULL) {
-               *uid = strtoul(s, NULL, 0);
-               talloc_free(tmp_ctx);
-               return NT_STATUS_OK;
-       }
-
-       /* next try via the UnixName attribute */
-       s = samdb_result_string(res[0], "unixName", NULL);
-       if (s != NULL) {
-               struct passwd *pwd = getpwnam(s);
-               if (!pwd) {
-                       DEBUG(0,("unixName %s for sid %s does not exist as a local user\n", s, 
-                                dom_sid_string(tmp_ctx, sid)));
-                       talloc_free(tmp_ctx);
-                       return NT_STATUS_NO_SUCH_USER;
-               }
-               *uid = pwd->pw_uid;
-               talloc_free(tmp_ctx);
-               return NT_STATUS_OK;
-       }
-
-       /* finally try via the sAMAccountName attribute */
-       s = samdb_result_string(res[0], "sAMAccountName", NULL);
-       if (s != NULL) {
-               struct passwd *pwd = getpwnam(s);
-               if (!pwd) {
-                       DEBUG(0,("sAMAccountName '%s' for sid %s does not exist as a local user\n", 
-                                s, dom_sid_string(tmp_ctx, sid)));
-                       talloc_free(tmp_ctx);
-                       return NT_STATUS_NO_SUCH_USER;
-               }
-               *uid = pwd->pw_uid;
-               talloc_free(tmp_ctx);
-               return NT_STATUS_OK;
-       }
-
-
-allocated_sid:
-       status = sidmap_primary_domain_sid(sidmap, tmp_ctx, &domain_sid);
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(tmp_ctx);
-               return NT_STATUS_NO_SUCH_DOMAIN;
-       }
-
-       if (dom_sid_in_domain(domain_sid, sid)) {
-               uint32_t rid = sid->sub_auths[sid->num_auths-1];
-               if (rid >= SIDMAP_LOCAL_USER_BASE && 
-                   rid <  SIDMAP_LOCAL_GROUP_BASE) {
-                       *uid = rid - SIDMAP_LOCAL_USER_BASE;
-                       talloc_free(tmp_ctx);
-                       return NT_STATUS_OK;
-               }
-       }
-       
-
-       DEBUG(0,("sid_to_unixuid: no uidNumber, unixName or sAMAccountName for sid %s\n", 
-                dom_sid_string(tmp_ctx, sid)));
-
-       talloc_free(tmp_ctx);
-       return NT_STATUS_NONE_MAPPED;
-}
-
-
-/*
-  see if a sid is a group - very inefficient!
-*/
-bool sidmap_sid_is_group(struct sidmap_context *sidmap, struct dom_sid *sid)
-{
-       const char *attrs[] = { "sAMAccountType", NULL };
-       int ret;
-       TALLOC_CTX *tmp_ctx;
-       struct ldb_message **res;
-       NTSTATUS status;
-       struct dom_sid *domain_sid;
-       bool is_group;
-
-       tmp_ctx = talloc_new(sidmap);
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs, 
-                          "objectSid=%s", ldap_encode_ndr_dom_sid(tmp_ctx, sid));
-       if (ret == 1) {
-               is_group = is_group_account(res[0]);
-               talloc_free(tmp_ctx);
-               return is_group;
-       }
-
-       status = sidmap_primary_domain_sid(sidmap, tmp_ctx, &domain_sid);
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(tmp_ctx);
-               return false;
-       }
-
-       if (dom_sid_in_domain(domain_sid, sid)) {
-               uint32_t rid = sid->sub_auths[sid->num_auths-1];
-               if (rid >= SIDMAP_LOCAL_GROUP_BASE) {
-                       talloc_free(tmp_ctx);
-                       return true;
-               }
-       }
-
-       talloc_free(tmp_ctx);
-       return false;
-}
-
-/*
-  map a sid to a unix gid
-*/
-NTSTATUS sidmap_sid_to_unixgid(struct sidmap_context *sidmap,
-                                       const struct dom_sid *sid, gid_t *gid)
-{
-       const char *attrs[] = { "sAMAccountName", "gidNumber",
-                               "unixName", "sAMAccountType", NULL };
-       int ret;
-       const char *s;
-       TALLOC_CTX *tmp_ctx;
-       struct ldb_message **res;
-       NTSTATUS status;
-       struct dom_sid *domain_sid;
-
-       tmp_ctx = talloc_new(sidmap);
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs, 
-                          "objectSid=%s", ldap_encode_ndr_dom_sid(tmp_ctx, sid));
-       if (ret != 1) {
-               goto allocated_sid;
-       }
-
-       /* make sure its not a user */
-       if (!is_group_account(res[0])) {
-               DEBUG(0,("sid_to_unixgid: sid %s is a ATYPE_NORMAL_ACCOUNT\n", 
-                        dom_sid_string(tmp_ctx, sid)));
-               talloc_free(tmp_ctx);
-               return NT_STATUS_INVALID_SID;
-       }
-
-       /* first try to get the gid directly */
-       s = samdb_result_string(res[0], "gidNumber", NULL);
-       if (s != NULL) {
-               *gid = strtoul(s, NULL, 0);
-               talloc_free(tmp_ctx);
-               return NT_STATUS_OK;
-       }
-
-       /* next try via the UnixName attribute */
-       s = samdb_result_string(res[0], "unixName", NULL);
-       if (s != NULL) {
-               struct group *grp = getgrnam(s);
-               if (!grp) {
-                       DEBUG(0,("unixName '%s' for sid %s does not exist as a local group\n", 
-                                s, dom_sid_string(tmp_ctx, sid)));
-                       talloc_free(tmp_ctx);
-                       return NT_STATUS_NO_SUCH_GROUP;
-               }
-               *gid = grp->gr_gid;
-               talloc_free(tmp_ctx);
-               return NT_STATUS_OK;
-       }
-
-       /* finally try via the sAMAccountName attribute */
-       s = samdb_result_string(res[0], "sAMAccountName", NULL);
-       if (s != NULL) {
-               struct group *grp = getgrnam(s);
-               if (!grp) {
-                       DEBUG(0,("sAMAccountName '%s' for sid %s does not exist as a local group\n", s, dom_sid_string(tmp_ctx, sid)));
-                       talloc_free(tmp_ctx);
-                       return NT_STATUS_NO_SUCH_GROUP;
-               }
-               *gid = grp->gr_gid;
-               talloc_free(tmp_ctx);
-               return NT_STATUS_OK;
-       }
-
-allocated_sid:
-       status = sidmap_primary_domain_sid(sidmap, tmp_ctx, &domain_sid);
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(tmp_ctx);
-               return NT_STATUS_NO_SUCH_DOMAIN;
-       }
-
-       if (dom_sid_in_domain(domain_sid, sid)) {
-               uint32_t rid = sid->sub_auths[sid->num_auths-1];
-               if (rid >= SIDMAP_LOCAL_GROUP_BASE) {
-                       *gid = rid - SIDMAP_LOCAL_GROUP_BASE;
-                       talloc_free(tmp_ctx);
-                       return NT_STATUS_OK;
-               }
-       }
-
-       DEBUG(0,("sid_to_unixgid: no gidNumber, unixName or sAMAccountName for sid %s\n", 
-                dom_sid_string(tmp_ctx, sid)));
-
-       talloc_free(tmp_ctx);
-       return NT_STATUS_NONE_MAPPED;
-}
-
-
-/*
-  map a unix uid to a dom_sid
-  the returned sid is allocated in the supplied mem_ctx
-*/
-NTSTATUS sidmap_uid_to_sid(struct sidmap_context *sidmap,
-                                   TALLOC_CTX *mem_ctx,
-                                   const uid_t uid, struct dom_sid **sid)
-{
-       const char *attrs[] = { "sAMAccountName", "objectSid", "sAMAccountType", NULL };
-       int ret, i;
-       TALLOC_CTX *tmp_ctx;
-       struct ldb_message **res;
-       struct passwd *pwd;
-       struct dom_sid *domain_sid;
-       NTSTATUS status;
-
-       /*
-         we search for the mapping in the following order:
-
-           - check if the uid is in the dynamic uid range assigned for winbindd
-             use. If it is, then look in winbindd sid mapping
-             database (not implemented yet)
-           - look for a user account in samdb that has uidNumber set to the
-             given uid
-           - look for a user account in samdb that has unixName or
-             sAMAccountName set to the name given by getpwuid()
-           - assign a SID by adding the uid to SIDMAP_LOCAL_USER_BASE in the local
-             domain
-       */
-
-
-       tmp_ctx = talloc_new(mem_ctx);
-
-
-       /*
-         step 2: look for a user account in samdb that has uidNumber set to the
-                  given uid
-       */
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs, 
-                          "uidNumber=%u", (unsigned int)uid);
-       for (i=0;i<ret;i++) {
-               if (!is_user_account(res[i])) continue;
-
-               *sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
-               talloc_free(tmp_ctx);
-               NT_STATUS_HAVE_NO_MEMORY(*sid);
-               return NT_STATUS_OK;
-       }
-
-       /*
-         step 3: look for a user account in samdb that has unixName
-                 or sAMAccountName set to the name given by getpwuid()
-       */
-       pwd = getpwuid(uid);
-       if (pwd == NULL) {
-               goto allocate_sid;
-       }
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs, 
-                          "(|(unixName=%s)(sAMAccountName=%s))", 
-                          pwd->pw_name, pwd->pw_name);
-       for (i=0;i<ret;i++) {
-               if (!is_user_account(res[i])) continue;
-
-               *sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
-               talloc_free(tmp_ctx);
-               NT_STATUS_HAVE_NO_MEMORY(*sid);
-               return NT_STATUS_OK;
-       }
-
-
-       /*
-           step 4: assign a SID by adding the uid to
-                   SIDMAP_LOCAL_USER_BASE in the local domain
-       */
-allocate_sid:
-       if (uid > SIDMAP_MAX_LOCAL_UID) {
-               return NT_STATUS_NONE_MAPPED;
-       }
-
-       status = sidmap_primary_domain_sid(sidmap, tmp_ctx, &domain_sid);
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(tmp_ctx);
-               return status;
-       }
-
-       *sid = dom_sid_add_rid(mem_ctx, domain_sid, SIDMAP_LOCAL_USER_BASE + uid);
-       talloc_free(tmp_ctx);
-
-       if (*sid == NULL) {
-               return NT_STATUS_NO_MEMORY;
-       }
-
-       return NT_STATUS_OK;
-}
-
-
-/*
-  map a unix gid to a dom_sid
-  the returned sid is allocated in the supplied mem_ctx
-*/
-NTSTATUS sidmap_gid_to_sid(struct sidmap_context *sidmap,
-                                   TALLOC_CTX *mem_ctx,
-                                   const gid_t gid, struct dom_sid **sid)
-{
-       const char *attrs[] = { "sAMAccountName", "objectSid", "sAMAccountType", NULL };
-       int ret, i;
-       TALLOC_CTX *tmp_ctx;
-       struct ldb_message **res;
-       struct group *grp;
-       struct dom_sid *domain_sid;
-       NTSTATUS status;
-
-       /*
-         we search for the mapping in the following order:
-
-           - check if the gid is in the dynamic gid range assigned for winbindd
-             use. If it is, then look in winbindd sid mapping
-             database (not implemented yet)
-           - look for a group account in samdb that has gidNumber set to the
-             given gid
-           - look for a group account in samdb that has unixName or
-             sAMAccountName set to the name given by getgrgid()
-           - assign a SID by adding the gid to SIDMAP_LOCAL_GROUP_BASE in the local
-             domain
-       */
-
-
-       tmp_ctx = talloc_new(sidmap);
-
-
-       /*
-         step 2: look for a group account in samdb that has gidNumber set to the
-                  given gid
-       */
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs, 
-                          "gidNumber=%u", (unsigned int)gid);
-       for (i=0;i<ret;i++) {
-               if (!is_group_account(res[i])) continue;
-
-               *sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
-               talloc_free(tmp_ctx);
-               NT_STATUS_HAVE_NO_MEMORY(*sid);
-               return NT_STATUS_OK;
-       }
-
-       /*
-         step 3: look for a group account in samdb that has unixName
-                 or sAMAccountName set to the name given by getgrgid()
-       */
-       grp = getgrgid(gid);
-       if (grp == NULL) {
-               goto allocate_sid;
-       }
-
-       ret = gendb_search(sidmap->samctx, tmp_ctx, NULL, &res, attrs, 
-                          "(|(unixName=%s)(sAMAccountName=%s))", 
-                          grp->gr_name, grp->gr_name);
-       for (i=0;i<ret;i++) {
-               if (!is_group_account(res[i])) continue;
-
-               *sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
-               talloc_free(tmp_ctx);
-               NT_STATUS_HAVE_NO_MEMORY(*sid);
-               return NT_STATUS_OK;
-       }
-
-
-       /*
-           step 4: assign a SID by adding the gid to
-                   SIDMAP_LOCAL_GROUP_BASE in the local domain
-       */
-allocate_sid:
-       if (gid > SIDMAP_MAX_LOCAL_GID) {
-               return NT_STATUS_NONE_MAPPED;
-       }
-
-       status = sidmap_primary_domain_sid(sidmap, tmp_ctx, &domain_sid);
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(tmp_ctx);
-               return status;
-       }
-
-       *sid = dom_sid_add_rid(mem_ctx, domain_sid, SIDMAP_LOCAL_GROUP_BASE + gid);
-       talloc_free(tmp_ctx);
-
-       if (*sid == NULL) {
-               return NT_STATUS_NO_MEMORY;
-       }
-
-       return NT_STATUS_OK;
-}
-
-/*
-  check if a sid is in the range of auto-allocated SIDs from our primary domain,
-  and if it is, then return the name and atype
-*/
-NTSTATUS sidmap_allocated_sid_lookup(struct sidmap_context *sidmap, 
-                                             TALLOC_CTX *mem_ctx, 
-                                             const struct dom_sid *sid,
-                                             const char **name,
-                                             enum lsa_SidType *rtype)
-{
-       NTSTATUS status;
-       struct dom_sid *domain_sid;
-       TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
-       uint32_t rid, atype;
-       
-       status = sidmap_primary_domain_sid(sidmap, tmp_ctx, &domain_sid);
-       if (!NT_STATUS_IS_OK(status)) {
-               return NT_STATUS_NO_SUCH_DOMAIN;
-       }
-
-       if (!dom_sid_in_domain(domain_sid, sid)) {
-               talloc_free(tmp_ctx);
-               return NT_STATUS_NONE_MAPPED;
-       }
-
-       talloc_free(tmp_ctx);
-
-       rid = sid->sub_auths[sid->num_auths-1];
-       if (rid < SIDMAP_LOCAL_USER_BASE) {
-               return NT_STATUS_NONE_MAPPED;
-       }
-
-       if (rid < SIDMAP_LOCAL_GROUP_BASE) {
-               struct passwd *pwd;
-               uid_t uid = rid - SIDMAP_LOCAL_USER_BASE;
-               atype = ATYPE_NORMAL_ACCOUNT;
-               *rtype = ds_atype_map(atype);
-
-               pwd = getpwuid(uid);
-               if (pwd == NULL) {
-                       *name = talloc_asprintf(mem_ctx, "uid%u", uid);
-               } else {
-                       *name = talloc_strdup(mem_ctx, pwd->pw_name);
-               }
-       } else {
-               struct group *grp;
-               gid_t gid = rid - SIDMAP_LOCAL_GROUP_BASE;
-               atype = ATYPE_LOCAL_GROUP;
-               *rtype = ds_atype_map(atype);
-               grp = getgrgid(gid);
-               if (grp == NULL) {
-                       *name = talloc_asprintf(mem_ctx, "gid%u", gid);
-               } else {
-                       *name = talloc_strdup(mem_ctx, grp->gr_name);
-               }
-       }
-
-       if (*name == NULL) {
-               return NT_STATUS_NO_MEMORY;
-       }
-
-       return NT_STATUS_OK;
-}

diff --git a/source4/dsdb/common/util.c b/source4/dsdb/common/util.c
index 45f19e93bbd0805e405bea72eead959f16f17dc0..c9562b0de73187824476d6aac888a9616e50cc8e 100644 (file)
--- a/source4/dsdb/common/util.c
+++ b/source4/dsdb/common/util.c
@@ -1432,63 +1432,6 @@ struct ldb_dn *samdb_server_site_dn(struct ldb_context *ldb, TALLOC_CTX *mem_ctx
        return server_site_dn;
 }
 
-/*
- * This works out if we are running on a supported forest/domain function
- * level. Basically this means that we don't support mixed/interim (NT 4 DC
- * support) levels.
- * If errmsg isn't NULL we write in an adequate error message for printing out
- * to the screen.
- */
-bool samdb_is_capable_dc(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
-       char **errmsg)
-{
-       int32_t level_forest, level_domain, level_domain_mixed;
-       bool ret = true;
-
-       level_forest = (int32_t) samdb_search_int64(ldb, mem_ctx, -1,
-               samdb_partitions_dn(ldb, mem_ctx), "msDS-Behavior-Version",
-               NULL);
-       level_domain = (int32_t) samdb_search_int64(ldb, mem_ctx, -1,
-               samdb_base_dn(ldb), "msDS-Behavior-Version", NULL);
-       level_domain_mixed = (int32_t) samdb_search_int64(ldb, mem_ctx, -1,
-               samdb_base_dn(ldb), "nTMixedDomain", NULL);
-
-       if (errmsg != NULL)
-               *errmsg = talloc_strdup(mem_ctx, "");
-
-       if (level_forest == -1 || level_domain == -1 || level_domain_mixed == -1) {
-               ret = false;
-               if (errmsg != NULL)
-                       *errmsg = talloc_strdup_append(*errmsg,
-                               "\nATTENTION: Invalid values for forest and/or domain function level!"
-                       );
-       }
-
-       if (level_forest == DS_DOMAIN_FUNCTION_2003_MIXED) {
-               ret = false;
-               if (errmsg != NULL)
-                       *errmsg = talloc_strdup_append(*errmsg,
-                               "\nATTENTION: You run SAMBA 4 on the 2003 with mixed domains (NT4 DC support) forest level. This isn't supported!"
-                       );
-       }
-       if ((level_domain == DS_DOMAIN_FUNCTION_2000 && level_domain_mixed != 0)
-               || level_domain == DS_DOMAIN_FUNCTION_2003_MIXED) {
-               ret = false;
-               if (errmsg != NULL)
-                       *errmsg = talloc_strdup_append(*errmsg,
-                               "\nATTENTION: You run SAMBA 4 on a mixed/interim (NT4 DC support) domain level. This isn't supported!"
-                       );
-       }
-
-       if ((!ret) && (errmsg != NULL)) {
-               *errmsg = talloc_strdup_append(*errmsg,
-                       "\nPlease raise the domain and/or forest level to an adequate value. Use for this the 'domainlevel' tool, the MS AD MMC tools or manipulate the needed attributes directly."
-               );
-       }
-
-       return ret;
-}
-
 /*
   work out if we are the PDC for the domain of the current open ldb
 */
@@ -1588,7 +1531,7 @@ int samdb_search_for_parent_domain(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
 
        while ((sdn = ldb_dn_get_parent(local_ctx, sdn))) {
                ret = ldb_search(ldb, local_ctx, &res, sdn, LDB_SCOPE_BASE, attrs,
-                                "(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain))");
+                                "(|(objectClass=domain)(objectClass=builtinDomain))");
                if (ret == LDB_SUCCESS) {
                        if (res->count == 1) {
                                break;
@@ -1640,21 +1583,22 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                            struct samr_Password *param_lmNewHash,
                            struct samr_Password *param_ntNewHash,
                            bool user_change,
-                           enum samr_RejectReason *reject_reason,
+                           enum samPwdChangeReason *reject_reason,
                            struct samr_DomInfo1 **_dominfo)
 {
-       const char * const user_attrs[] = { "userAccountControl", "lmPwdHistory", 
+       const char * const user_attrs[] = { "userAccountControl",
+                                           "lmPwdHistory",
                                            "ntPwdHistory", 
                                            "dBCSPwd", "unicodePwd", 
                                            "objectSid", 
                                            "pwdLastSet", NULL };
-       const char * const domain_attrs[] = { "pwdProperties", "pwdHistoryLength", 
-                                             "maxPwdAge", "minPwdAge", 
-                                             "minPwdLength", NULL };
+       const char * const domain_attrs[] = { "minPwdLength", "pwdProperties",
+                                             "pwdHistoryLength",
+                                             "maxPwdAge", "minPwdAge", NULL };
        NTTIME pwdLastSet;
-       int64_t minPwdAge;
-       uint_t minPwdLength, pwdProperties, pwdHistoryLength;
-       uint_t userAccountControl;
+       uint32_t minPwdLength, pwdProperties, pwdHistoryLength;
+       int64_t maxPwdAge, minPwdAge;
+       uint32_t userAccountControl;
        struct samr_Password *sambaLMPwdHistory, *sambaNTPwdHistory,
                *lmPwdHash, *ntPwdHash, *lmNewHash, *ntNewHash;
        struct samr_Password local_lmNewHash, local_ntNewHash;
@@ -1675,14 +1619,14 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
        if (count != 1) {
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
-       userAccountControl = samdb_result_uint(res[0],   "userAccountControl", 0);
-       sambaLMPwdHistory_len =   samdb_result_hashes(mem_ctx, res[0], 
-                                                "lmPwdHistory", &sambaLMPwdHistory);
-       sambaNTPwdHistory_len =   samdb_result_hashes(mem_ctx, res[0], 
-                                                "ntPwdHistory", &sambaNTPwdHistory);
-       lmPwdHash =          samdb_result_hash(mem_ctx, res[0],   "dBCSPwd");
-       ntPwdHash =          samdb_result_hash(mem_ctx, res[0],   "unicodePwd");
-       pwdLastSet =         samdb_result_uint64(res[0], "pwdLastSet", 0);
+       userAccountControl = samdb_result_uint(res[0], "userAccountControl", 0);
+       sambaLMPwdHistory_len = samdb_result_hashes(mem_ctx, res[0],
+                                        "lmPwdHistory", &sambaLMPwdHistory);
+       sambaNTPwdHistory_len = samdb_result_hashes(mem_ctx, res[0],
+                                        "ntPwdHistory", &sambaNTPwdHistory);
+       lmPwdHash = samdb_result_hash(mem_ctx, res[0], "dBCSPwd");
+       ntPwdHash = samdb_result_hash(mem_ctx, res[0], "unicodePwd");
+       pwdLastSet = samdb_result_uint64(res[0], "pwdLastSet", 0);
 
        /* Copy parameters */
        lmNewHash = param_lmNewHash;
@@ -1695,9 +1639,10 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                                               |UF_WORKSTATION_TRUST_ACCOUNT
                                               |UF_SERVER_TRUST_ACCOUNT)); 
 
-       if (domain_dn) {
+       if (domain_dn != NULL) {
                /* pull the domain parameters */
-               count = gendb_search_dn(ctx, mem_ctx, domain_dn, &res, domain_attrs);
+               count = gendb_search_dn(ctx, mem_ctx, domain_dn, &res,
+                                                               domain_attrs);
                if (count != 1) {
                        DEBUG(2, ("samdb_set_password: Domain DN %s is invalid, for user %s\n", 
                                  ldb_dn_get_linearized(domain_dn),
@@ -1706,14 +1651,15 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                }
        } else {
                /* work out the domain sid, and pull the domain from there */
-               domain_sid =         samdb_result_sid_prefix(mem_ctx, res[0], "objectSid");
+               domain_sid = samdb_result_sid_prefix(mem_ctx, res[0],
+                                                               "objectSid");
                if (domain_sid == NULL) {
                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
                }
 
                count = gendb_search(ctx, mem_ctx, NULL, &res, domain_attrs, 
-                                    "(objectSid=%s)", 
-                                    ldap_encode_ndr_dom_sid(mem_ctx, domain_sid));
+                               "(objectSid=%s)",
+                               ldap_encode_ndr_dom_sid(mem_ctx, domain_sid));
                if (count != 1) {
                        DEBUG(2, ("samdb_set_password: Could not find domain to match SID: %s, for user %s\n", 
                                  dom_sid_string(mem_ctx, domain_sid),
@@ -1722,17 +1668,18 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                }
        }
 
-       pwdProperties =    samdb_result_uint(res[0],   "pwdProperties", 0);
-       pwdHistoryLength = samdb_result_uint(res[0],   "pwdHistoryLength", 0);
-       minPwdLength =     samdb_result_uint(res[0],   "minPwdLength", 0);
-       minPwdAge =        samdb_result_int64(res[0],  "minPwdAge", 0);
+       minPwdLength = samdb_result_uint(res[0], "minPwdLength", 0);
+       pwdProperties = samdb_result_uint(res[0], "pwdProperties", 0);
+       pwdHistoryLength = samdb_result_uint(res[0], "pwdHistoryLength", 0);
+       maxPwdAge = samdb_result_int64(res[0], "maxPwdAge", 0);
+       minPwdAge = samdb_result_int64(res[0], "minPwdAge", 0);
 
-       if (userAccountControl & UF_PASSWD_NOTREQD) {
+       if ((userAccountControl & UF_PASSWD_NOTREQD) != 0) {
                /* see [MS-ADTS] 2.2.15 */
                minPwdLength = 0;
        }
 
-       if (_dominfo) {
+       if (_dominfo != NULL) {
                struct samr_DomInfo1 *dominfo;
                /* on failure we need to fill in the reject reasons */
                dominfo = talloc(mem_ctx, struct samr_DomInfo1);
@@ -1742,24 +1689,27 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                dominfo->min_password_length     = minPwdLength;
                dominfo->password_properties     = pwdProperties;
                dominfo->password_history_length = pwdHistoryLength;
-               dominfo->max_password_age        = minPwdAge;
+               dominfo->max_password_age        = maxPwdAge;
                dominfo->min_password_age        = minPwdAge;
                *_dominfo = dominfo;
        }
 
-       if (restrictions && new_password) {
+       if ((restrictions != 0) && (new_password != 0)) {
                char *new_pass;
 
-               /* check the various password restrictions */
-               if (restrictions && minPwdLength > utf16_len_n(new_password->data, new_password->length) / 2) {
+               /* checks if the "minPwdLength" property is satisfied */
+               if ((restrictions != 0)
+                       && (minPwdLength > utf16_len_n(
+                               new_password->data, new_password->length)/2)) {
                        if (reject_reason) {
-                               *reject_reason = SAMR_REJECT_TOO_SHORT;
+                               *reject_reason = SAM_PWD_CHANGE_PASSWORD_TOO_SHORT;
                        }
                        return NT_STATUS_PASSWORD_RESTRICTION;
                }
 
                /* Create the NT hash */
-               mdfour(local_ntNewHash.hash, new_password->data, new_password->length);
+               mdfour(local_ntNewHash.hash, new_password->data,
+                                                       new_password->length);
 
                ntNewHash = &local_ntNewHash;
 
@@ -1770,11 +1720,13 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                          new_password->data, new_password->length,
                          (void **)&new_pass, NULL, false)) {
 
-                       /* possibly check password complexity */
-                       if (restrictions && (pwdProperties & DOMAIN_PASSWORD_COMPLEX) &&
-                           !check_password_quality(new_pass)) {
+                       /* checks the password complexity */
+                       if ((restrictions != 0)
+                               && ((pwdProperties
+                                       & DOMAIN_PASSWORD_COMPLEX) != 0)
+                               && (!check_password_quality(new_pass))) {
                                if (reject_reason) {
-                                       *reject_reason = SAMR_REJECT_COMPLEXITY;
+                                       *reject_reason = SAM_PWD_CHANGE_NOT_COMPLEX;
                                }
                                return NT_STATUS_PASSWORD_RESTRICTION;
                        }
@@ -1786,63 +1738,69 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                }
        }
 
-       if (restrictions && user_change) {
+       if ((restrictions != 0) && user_change) {
                /* are all password changes disallowed? */
-               if (pwdProperties & DOMAIN_REFUSE_PASSWORD_CHANGE) {
+               if ((pwdProperties & DOMAIN_REFUSE_PASSWORD_CHANGE) != 0) {
                        if (reject_reason) {
-                               *reject_reason = SAMR_REJECT_OTHER;
+                               *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                        }
                        return NT_STATUS_PASSWORD_RESTRICTION;
                }
 
-               /* can this user change password? */
-               if (userAccountControl & UF_PASSWD_CANT_CHANGE) {
+               /* can this user change the password? */
+               if ((userAccountControl & UF_PASSWD_CANT_CHANGE) != 0) {
                        if (reject_reason) {
-                               *reject_reason = SAMR_REJECT_OTHER;
+                               *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                        }
                        return NT_STATUS_PASSWORD_RESTRICTION;
                }
 
-               /* yes, this is a minus. The ages are in negative 100nsec units! */
+               /* Password minimum age: yes, this is a minus. The ages are in negative 100nsec units! */
                if (pwdLastSet - minPwdAge > now_nt) {
                        if (reject_reason) {
-                               *reject_reason = SAMR_REJECT_OTHER;
+                               *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                        }
                        return NT_STATUS_PASSWORD_RESTRICTION;
                }
 
                /* check the immediately past password */
                if (pwdHistoryLength > 0) {
-                       if (lmNewHash && lmPwdHash && memcmp(lmNewHash->hash, lmPwdHash->hash, 16) == 0) {
+                       if (lmNewHash && lmPwdHash && memcmp(lmNewHash->hash,
+                                       lmPwdHash->hash, 16) == 0) {
                                if (reject_reason) {
-                                       *reject_reason = SAMR_REJECT_IN_HISTORY;
+                                       *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
                                }
                                return NT_STATUS_PASSWORD_RESTRICTION;
                        }
-                       if (ntNewHash && ntPwdHash && memcmp(ntNewHash->hash, ntPwdHash->hash, 16) == 0) {
+                       if (ntNewHash && ntPwdHash && memcmp(ntNewHash->hash,
+                                       ntPwdHash->hash, 16) == 0) {
                                if (reject_reason) {
-                                       *reject_reason = SAMR_REJECT_IN_HISTORY;
+                                       *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
                                }
                                return NT_STATUS_PASSWORD_RESTRICTION;
                        }
                }
 
                /* check the password history */
-               sambaLMPwdHistory_len = MIN(sambaLMPwdHistory_len, pwdHistoryLength);
-               sambaNTPwdHistory_len = MIN(sambaNTPwdHistory_len, pwdHistoryLength);
+               sambaLMPwdHistory_len = MIN(sambaLMPwdHistory_len,
+                                                       pwdHistoryLength);
+               sambaNTPwdHistory_len = MIN(sambaNTPwdHistory_len,
+                                                       pwdHistoryLength);
 
                for (i=0; lmNewHash && i<sambaLMPwdHistory_len;i++) {
-                       if (memcmp(lmNewHash->hash, sambaLMPwdHistory[i].hash, 16) == 0) {
+                       if (memcmp(lmNewHash->hash, sambaLMPwdHistory[i].hash,
+                                       16) == 0) {
                                if (reject_reason) {
-                                       *reject_reason = SAMR_REJECT_IN_HISTORY;
+                                       *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
                                }
                                return NT_STATUS_PASSWORD_RESTRICTION;
                        }
                }
                for (i=0; ntNewHash && i<sambaNTPwdHistory_len;i++) {
-                       if (memcmp(ntNewHash->hash, sambaNTPwdHistory[i].hash, 16) == 0) {
+                       if (memcmp(ntNewHash->hash, sambaNTPwdHistory[i].hash,
+                                        16) == 0) {
                                if (reject_reason) {
-                                       *reject_reason = SAMR_REJECT_IN_HISTORY;
+                                       *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
                                }
                                return NT_STATUS_PASSWORD_RESTRICTION;
                        }
@@ -1852,7 +1810,7 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
 #define CHECK_RET(x) do { if (x != 0) return NT_STATUS_NO_MEMORY; } while(0)
 
        /* the password is acceptable. Start forming the new fields */
-       if (new_password) {
+       if (new_password != NULL) {
                /* if we know the cleartext UTF16 password, then set it.
                 * Modules in ldb will set all the appropriate
                 * hashes */
@@ -1875,6 +1833,9 @@ NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                }
        }
 
+       if (reject_reason) {
+               *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
+       }
        return NT_STATUS_OK;
 }
 
@@ -1893,7 +1854,7 @@ NTSTATUS samdb_set_password_sid(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
                                struct samr_Password *lmNewHash, 
                                struct samr_Password *ntNewHash,
                                bool user_change,
-                               enum samr_RejectReason *reject_reason,
+                               enum samPwdChangeReason *reject_reason,
                                struct samr_DomInfo1 **_dominfo) 
 {
        NTSTATUS nt_status;
@@ -2567,3 +2528,53 @@ int drsuapi_DsReplicaCursor2_compare(const struct drsuapi_DsReplicaCursor2 *c1,
 {
        return GUID_compare(&c1->source_dsa_invocation_id, &c2->source_dsa_invocation_id);
 }
+
+/*
+  see if we are a RODC
+
+  TODO: This should take a sam_ctx, and lookup the right object (with
+  a cache)
+*/
+bool samdb_rodc(struct loadparm_context *lp_ctx)
+{
+       return lp_parm_bool(lp_ctx, NULL, "repl", "RODC", false);
+}
+
+
+/*
+  return NTDS options flags. See MS-ADTS 7.1.1.2.2.1.2.1.1 
+
+  flags are DS_NTDS_OPTION_*
+*/
+int samdb_ntds_options(struct ldb_context *ldb, uint32_t *options)
+{
+       TALLOC_CTX *tmp_ctx;
+       const char *attrs[] = { "options", NULL };
+       int ret;
+       struct ldb_result *res;
+
+       tmp_ctx = talloc_new(ldb);
+       if (tmp_ctx == NULL) {
+               goto failed;
+       }
+
+       ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
+       if (ret) {
+               goto failed;
+       }
+
+       if (res->count != 1) {
+               goto failed;
+       }
+
+       *options = samdb_result_uint(res->msgs[0], "options", 0);
+
+       talloc_free(tmp_ctx);
+
+       return LDB_SUCCESS;
+
+failed:
+       DEBUG(1,("Failed to find our own NTDS Settings objectGUID in the ldb!\n"));
+       talloc_free(tmp_ctx);
+       return LDB_ERR_NO_SUCH_OBJECT;
+}

diff --git a/source4/dsdb/config.mk b/source4/dsdb/config.mk
index 4150ba0d5407fa8a7589b2d8765f8b689fb53edb..59daa745e9727fea8c853666a18dac1be89225cc 100644 (file)
--- a/source4/dsdb/config.mk
+++ b/source4/dsdb/config.mk
@@ -25,7 +25,6 @@ $(eval $(call proto_header_template,$(dsdbsrcdir)/samdb/samdb_proto.h,$(SAMDB_OB
 PRIVATE_DEPENDENCIES = LIBLDB
 
 SAMDB_COMMON_OBJ_FILES = $(addprefix $(dsdbsrcdir)/common/, \
-               sidmap.o \
                util.o) \
                ../libds/common/flag_mapping.o
 $(eval $(call proto_header_template,$(dsdbsrcdir)/common/proto.h,$(SAMDB_COMMON_OBJ_FILES:.o=.c)))
@@ -40,7 +39,8 @@ SAMDB_SCHEMA_OBJ_FILES = $(addprefix $(dsdbsrcdir)/schema/, \
                schema_syntax.o \
                schema_description.o \
                schema_convert_to_ol.o \
-               schema_inferiors.o)
+               schema_inferiors.o \
+               schema_prefixmap.o)
 
 $(eval $(call proto_header_template,$(dsdbsrcdir)/schema/proto.h,$(SAMDB_SCHEMA_OBJ_FILES:.o=.c)))
 # PUBLIC_HEADERS += dsdb/schema/schema.h

diff --git a/source4/dsdb/kcc/kcc_periodic.c b/source4/dsdb/kcc/kcc_periodic.c
index 44e0c7ae8bc5178c6300805914c0dfe542b4910c..30d43033cbc80402dca36b812d640906662f92b2 100644 (file)
--- a/source4/dsdb/kcc/kcc_periodic.c
+++ b/source4/dsdb/kcc/kcc_periodic.c
@@ -152,7 +152,7 @@ static NTSTATUS kccsrv_simple_update(struct kccsrv_service *s, TALLOC_CTX *mem_c
                r1->other_info               = talloc_zero(reps, struct repsFromTo1OtherInfo);
                r1->other_info->dns_name     = talloc_asprintf(r1->other_info, "%s._msdcs.%s",
                                                               GUID_string(mem_ctx, &ntds_guid),
-                                                              lp_realm(s->task->lp_ctx));
+                                                              lp_dnsdomain(s->task->lp_ctx));
                r1->source_dsa_obj_guid      = ntds_guid;
                r1->source_dsa_invocation_id = invocation_id;
                r1->replica_flags            = 

diff --git a/source4/dsdb/repl/drepl_out_helpers.c b/source4/dsdb/repl/drepl_out_helpers.c
index 5c63c111f3af0f4b6de77c90c6f432971dc48e28..c86956c42f5d5b38baf3d120e2fed2c596de0c87 100644 (file)
--- a/source4/dsdb/repl/drepl_out_helpers.c
+++ b/source4/dsdb/repl/drepl_out_helpers.c
@@ -506,10 +506,9 @@ static void dreplsrv_update_refs_send(struct dreplsrv_op_pull_source_state *st)
        ntds_guid_str = GUID_string(r, &service->ntds_guid);
        if (composite_nomem(ntds_guid_str, c)) return;
 
-       /* lp_realm() is not really right here */
        ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
                                        ntds_guid_str,
-                                       lp_realm(service->task->lp_ctx));
+                                       lp_dnsdomain(service->task->lp_ctx));
        if (composite_nomem(ntds_dns_name, c)) return;
 
        r->in.bind_handle       = &drsuapi->bind_handle;
@@ -520,7 +519,7 @@ static void dreplsrv_update_refs_send(struct dreplsrv_op_pull_source_state *st)
        r->in.req.req1.options            = 
                DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE |
                DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE;
-       if (!lp_parm_bool(service->task->lp_ctx, NULL, "repl", "RODC", false)) {
+       if (!samdb_rodc(service->task->lp_ctx)) {
                r->in.req.req1.options |= DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE;
        }
 

diff --git a/source4/dsdb/repl/replicated_objects.c b/source4/dsdb/repl/replicated_objects.c
index 5d7ae11a57b0e1cde856d788bfa7f12e34af4511..ec5dcd472054964ef561a28b3b82e21e381e5631 100644 (file)
--- a/source4/dsdb/repl/replicated_objects.c
+++ b/source4/dsdb/repl/replicated_objects.c
@@ -424,35 +424,78 @@ WERROR dsdb_origin_objects_commit(struct ldb_context *ldb,
                return WERR_OK;
        }
 
+       ret = ldb_transaction_start(ldb);
+       if (ret != LDB_SUCCESS) {
+               return WERR_DS_INTERNAL_FAILURE;
+       }
+
        objects = talloc_array(mem_ctx, struct ldb_message *,
                               num_objects);
-       W_ERROR_HAVE_NO_MEMORY(objects);
+       if (objects == NULL) {
+               status = WERR_NOMEM;
+               goto cancel;
+       }
 
        for (i=0, cur = first_object; cur; cur = cur->next_object, i++) {
                status = dsdb_convert_object(ldb, schema,
                                             cur, objects, &objects[i]);
-               W_ERROR_NOT_OK_RETURN(status);
+               if (!W_ERROR_IS_OK(status)) {
+                       goto cancel;
+               }
        }
 
        ids = talloc_array(mem_ctx,
                           struct drsuapi_DsReplicaObjectIdentifier2,
                           num_objects);
-       W_ERROR_HAVE_NO_MEMORY(objects);
+       if (ids == NULL) {
+               status = WERR_NOMEM;
+               goto cancel;
+       }
 
        for (i=0; i < num_objects; i++) {
                struct dom_sid *sid = NULL;
+               struct ldb_request *add_req;
 
                DEBUG(6,(__location__ ": adding %s\n", 
                         ldb_dn_get_linearized(objects[i]->dn)));
+
+               ret = ldb_build_add_req(&add_req,
+                                       ldb,
+                                       objects,
+                                       objects[i],
+                                       NULL,
+                                       NULL,
+                                       ldb_op_default_callback,
+                                       NULL);
+               if (ret != LDB_SUCCESS) {
+                       status = WERR_DS_INTERNAL_FAILURE;
+                       goto cancel;
+               }
+
+               ret = ldb_request_add_control(add_req, LDB_CONTROL_RELAX_OID, true, NULL);
+               if (ret != LDB_SUCCESS) {
+                       status = WERR_DS_INTERNAL_FAILURE;
+                       goto cancel;
+               }
                
-               ret = ldb_add(ldb, objects[i]);
-               if (ret != 0) {
+               ret = ldb_request(ldb, add_req);
+               if (ret == LDB_SUCCESS) {
+                       ret = ldb_wait(add_req->handle, LDB_WAIT_ALL);
+               }
+               if (ret != LDB_SUCCESS) {
+                       DEBUG(0,(__location__ ": Failed add of %s - %s\n",
+                                ldb_dn_get_linearized(objects[i]->dn), ldb_errstring(ldb)));
+                       status = WERR_DS_INTERNAL_FAILURE;
                        goto cancel;
                }
+
+               talloc_free(add_req);
+
                ret = ldb_search(ldb, objects, &res, objects[i]->dn,
                                 LDB_SCOPE_BASE, attrs,
                                 "(objectClass=*)");
-               if (ret != 0) {
+               if (ret != LDB_SUCCESS) {
+                       status = WERR_DS_INTERNAL_FAILURE;
                        goto cancel;
                }
                ids[i].guid = samdb_result_guid(res->msgs[0], "objectGUID");
@@ -464,13 +507,19 @@ WERROR dsdb_origin_objects_commit(struct ldb_context *ldb,
                }
        }
 
+       ret = ldb_transaction_commit(ldb);
+       if (ret != LDB_SUCCESS) {
+               return WERR_DS_INTERNAL_FAILURE;
+       }
+
        talloc_free(objects);
 
        *_num = num_objects;
        *_ids = ids;
        return WERR_OK;
+
 cancel:
        talloc_free(objects);
        ldb_transaction_cancel(ldb);
-       return WERR_FOOBAR;
+       return status;
 }

diff --git a/source4/dsdb/samdb/cracknames.c b/source4/dsdb/samdb/cracknames.c
index 723f51356a5c36a512298379d5405b7a172077fe..8f7f481e2db6b03ae2d5801d482367b3270292b2 100644 (file)
--- a/source4/dsdb/samdb/cracknames.c
+++ b/source4/dsdb/samdb/cracknames.c
@@ -1288,11 +1288,9 @@ NTSTATUS crack_name_to_nt4_name(TALLOC_CTX *mem_ctx,
        }
        p[0] = '\0';
 
-       if (p[1]) {
-               *nt4_account = talloc_strdup(mem_ctx, &p[1]);
-               if (*nt4_account == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-               }
+       *nt4_account = talloc_strdup(mem_ctx, &p[1]);
+       if (*nt4_account == NULL) {
+               return NT_STATUS_NO_MEMORY;
        }
 
        return NT_STATUS_OK;

diff --git a/source4/dsdb/samdb/ldb_modules/acl.c b/source4/dsdb/samdb/ldb_modules/acl.c
index 1b02abcb8e21a74a84385841a116bf5a73d9908d..2f123145dbae22b4c3e1a97010036c4cf0083deb 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/acl.c
+++ b/source4/dsdb/samdb/ldb_modules/acl.c
@@ -802,6 +802,7 @@ static int acl_modify(struct ldb_module *module, struct ldb_request *req)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
+/* TODO Is this really right? */
 /*     if (what_is_user(module) == SECURITY_SYSTEM) */
                return ldb_next_request(module, req);
 
@@ -813,7 +814,7 @@ static int acl_modify(struct ldb_module *module, struct ldb_request *req)
        ac->user_type = what_is_user(module);
        ac->sec_result = LDB_SUCCESS;
        if (!is_root_base_dn(ldb, req->op.mod.message->dn) && parent && !is_root_base_dn(ldb, parent)){
-         filter = talloc_asprintf(req,"(&(objectClass=*)(|(%s=%s)(%s=%s))))",
+               filter = talloc_asprintf(req,"(&(objectClass=*)(|(%s=%s)(%s=%s))))",
                                   ldb_dn_get_component_name(parent,0),
                                   ldb_dn_get_component_val(parent,0)->data,
                                   ldb_dn_get_component_name(req->op.mod.message->dn,0),

diff --git a/source4/dsdb/samdb/ldb_modules/anr.c b/source4/dsdb/samdb/ldb_modules/anr.c
index deeccac072a84216ac081a65001f64760afde44e..a5220b3f915bb5190101a88b7de0e768c046bdeb 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/anr.c
+++ b/source4/dsdb/samdb/ldb_modules/anr.c
@@ -67,8 +67,10 @@ static struct ldb_parse_tree *make_parse_list(struct ldb_module *module,
  * Make an equality or prefix match tree, from the attribute, operation and matching value supplied
  */
 static struct ldb_parse_tree *make_match_tree(struct ldb_module *module,
-                                      TALLOC_CTX *mem_ctx, enum ldb_parse_op op, 
-                                      const char *attr, const DATA_BLOB *match)
+                                             TALLOC_CTX *mem_ctx,
+                                             enum ldb_parse_op op,
+                                             const char *attr,
+                                             struct ldb_val *match)
 {
        struct ldb_context *ldb;
        struct ldb_parse_tree *match_tree;
@@ -123,7 +125,7 @@ struct anr_context {
  */
 static int anr_replace_value(struct anr_context *ac,
                             TALLOC_CTX *mem_ctx,
-                            const struct ldb_val *match,
+                            struct ldb_val *match,
                             struct ldb_parse_tree **ntree)
 {
        struct ldb_parse_tree *tree = NULL;
@@ -146,7 +148,7 @@ static int anr_replace_value(struct anr_context *ac,
        ac->found_anr = true;
 
        if (match->length > 1 && match->data[0] == '=') {
-               DATA_BLOB *match2 = talloc(mem_ctx, DATA_BLOB);
+               struct ldb_val *match2 = talloc(mem_ctx, struct ldb_val);
                *match2 = data_blob_const(match->data+1, match->length - 1);
                if (match2 == NULL){
                        ldb_oom(ldb);
@@ -181,8 +183,8 @@ static int anr_replace_value(struct anr_context *ac,
 
        if (p) {
                struct ldb_parse_tree *first_split_filter, *second_split_filter, *split_filters, *match_tree_1, *match_tree_2;
-               DATA_BLOB *first_match = talloc(tree, DATA_BLOB);
-               DATA_BLOB *second_match = talloc(tree, DATA_BLOB);
+               struct ldb_val *first_match = talloc(tree, struct ldb_val);
+               struct ldb_val *second_match = talloc(tree, struct ldb_val);
                if (!first_match || !second_match) {
                        ldb_oom(ldb);
                        return LDB_ERR_OPERATIONS_ERROR;

diff --git a/source4/dsdb/samdb/ldb_modules/config.mk b/source4/dsdb/samdb/ldb_modules/config.mk
index a49b238591d608d616dc95081a50ac8bfdf41638..ea4e7228226e431f82b349a3b080c67a8a79ed6a 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/config.mk
+++ b/source4/dsdb/samdb/ldb_modules/config.mk
@@ -1,3 +1,13 @@
+################################################
+# Start SUBSYSTEM DSDB_MODULE_HELPERS
+[SUBSYSTEM::DSDB_MODULE_HELPERS]
+PRIVATE_DEPENDENCIES = LIBLDB
+
+DSDB_MODULE_HELPERS_OBJ_FILES = $(dsdbsrcdir)/samdb/ldb_modules/util.o
+
+$(eval $(call proto_header_template,$(dsdbsrcdir)/samdb/ldb_modules/util_proto.h,$(DSDB_MODULE_HELPERS_OBJ_FILES:.o=.c)))
+
+
 ################################################
 # Start MODULE ldb_objectguid
 [MODULE::ldb_objectguid]
@@ -15,7 +25,7 @@ ldb_objectguid_OBJ_FILES = $(dsdbsrcdir)/samdb/ldb_modules/objectguid.o
 SUBSYSTEM = LIBLDB
 PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS \
                        LIBNDR NDR_DRSUAPI \
-                       NDR_DRSBLOBS LIBNDR
+                       NDR_DRSBLOBS LIBNDR DSDB_MODULE_HELPERS
 INIT_FUNCTION = LDB_MODULE(repl_meta_data)
 # End MODULE ldb_repl_meta_data
 ################################################
@@ -39,7 +49,7 @@ ldb_dsdb_cache_OBJ_FILES = \
 # Start MODULE ldb_schema_fsmo
 [MODULE::ldb_schema_fsmo]
 SUBSYSTEM = LIBLDB
-PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS
+PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS DSDB_MODULE_HELPERS
 INIT_FUNCTION = LDB_MODULE(schema_fsmo)
 # End MODULE ldb_schema_fsmo
 ################################################
@@ -51,7 +61,7 @@ ldb_schema_fsmo_OBJ_FILES = \
 # Start MODULE ldb_naming_fsmo
 [MODULE::ldb_naming_fsmo]
 SUBSYSTEM = LIBLDB
-PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS
+PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS DSDB_MODULE_HELPERS
 INIT_FUNCTION = LDB_MODULE(naming_fsmo)
 # End MODULE ldb_naming_fsmo
 ################################################
@@ -63,7 +73,7 @@ ldb_naming_fsmo_OBJ_FILES = \
 # Start MODULE ldb_pdc_fsmo
 [MODULE::ldb_pdc_fsmo]
 SUBSYSTEM = LIBLDB
-PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS
+PRIVATE_DEPENDENCIES = SAMDB LIBTALLOC LIBEVENTS DSDB_MODULE_HELPERS
 INIT_FUNCTION = LDB_MODULE(pdc_fsmo)
 # End MODULE ldb_pdc_fsmo
 ################################################
@@ -220,7 +230,7 @@ ldb_show_deleted_OBJ_FILES = $(dsdbsrcdir)/samdb/ldb_modules/show_deleted.o
 # Start MODULE ldb_partition
 [MODULE::ldb_partition]
 SUBSYSTEM = LIBLDB
-PRIVATE_DEPENDENCIES = LIBTALLOC LIBEVENTS SAMDB
+PRIVATE_DEPENDENCIES = LIBTALLOC LIBEVENTS SAMDB DSDB_MODULE_HELPERS
 INIT_FUNCTION = LDB_MODULE(partition)
 # End MODULE ldb_partition
 ################################################
@@ -369,3 +379,15 @@ INIT_FUNCTION = LDB_MODULE(acl)
 ################################################
 
 ldb_acl_OBJ_FILES = $(dsdbsrcdir)/samdb/ldb_modules/acl.o
+
+################################################
+# Start MODULE ldb_lazy_commit
+[MODULE::ldb_lazy_commit]
+PRIVATE_DEPENDENCIES = SAMDB
+SUBSYSTEM = LIBLDB
+INIT_FUNCTION = LDB_MODULE(lazy_commit)
+
+# End MODULE ldb_lazy_commit
+################################################
+
+ldb_lazy_commit_OBJ_FILES = $(dsdbsrcdir)/samdb/ldb_modules/lazy_commit.o

diff --git a/source4/dsdb/samdb/ldb_modules/extended_dn_out.c b/source4/dsdb/samdb/ldb_modules/extended_dn_out.c
index f93090ace9589853e7c49a7f81d561bec95f0a3f..bb5e3795dbccec98abd715a991f6e49390f55245 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/extended_dn_out.c
+++ b/source4/dsdb/samdb/ldb_modules/extended_dn_out.c
@@ -340,7 +340,8 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
                }
 
                /* Look to see if this attributeSyntax is a DN */
-               if (strcmp(attribute->attributeSyntax_oid, "2.5.5.1") != 0) {
+               if (strcmp(attribute->attributeSyntax_oid, "2.5.5.1") != 0 &&
+                   strcmp(attribute->attributeSyntax_oid, "2.5.5.7") != 0) {
                        continue;
                }
 
@@ -617,7 +618,8 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
                        NULL
                };
 
-               if (strcmp(cur->syntax->attributeSyntax_oid, "2.5.5.1") != 0) {
+               if (strcmp(cur->syntax->attributeSyntax_oid, "2.5.5.1") != 0 &&
+                   strcmp(cur->syntax->attributeSyntax_oid, "2.5.5.7") != 0) {
                        continue;
                }
                dereference_control->dereference

diff --git a/source4/dsdb/samdb/ldb_modules/extended_dn_store.c b/source4/dsdb/samdb/ldb_modules/extended_dn_store.c
index 3234f6f269d0665e5e06156aab38b1bc223e7bd6..122a9bb2b7d648897674fa53ce9ee1818f94d023 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/extended_dn_store.c
+++ b/source4/dsdb/samdb/ldb_modules/extended_dn_store.c
@@ -303,7 +303,8 @@ static int extended_dn_add(struct ldb_module *module, struct ldb_request *req)
                }
 
                /* We only setup an extended DN GUID on these particular DN objects */
-               if (strcmp(schema_attr->attributeSyntax_oid, "2.5.5.1") != 0) {
+               if (strcmp(schema_attr->attributeSyntax_oid, "2.5.5.1") != 0 &&
+                   strcmp(schema_attr->attributeSyntax_oid, "2.5.5.7") != 0) {
                        continue;
                }
 
@@ -376,7 +377,8 @@ static int extended_dn_modify(struct ldb_module *module, struct ldb_request *req
                }
 
                /* We only setup an extended DN GUID on these particular DN objects */
-               if (strcmp(schema_attr->attributeSyntax_oid, "2.5.5.1") != 0) {
+               if (strcmp(schema_attr->attributeSyntax_oid, "2.5.5.1") != 0 &&
+                   strcmp(schema_attr->attributeSyntax_oid, "2.5.5.7") != 0) {
                        continue;
                }
                

diff --git a/source4/dsdb/samdb/ldb_modules/instancetype.c b/source4/dsdb/samdb/ldb_modules/instancetype.c
index de46c0a42aa3982ee311b403d1f900ac4a54f9ca..201ed044125c8a6400e858612b79d52a3d0ffe20 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/instancetype.c
+++ b/source4/dsdb/samdb/ldb_modules/instancetype.c
@@ -77,8 +77,6 @@ static int instancetype_add(struct ldb_module *module, struct ldb_request *req)
        struct it_context *ac;
        uint32_t instance_type;
        int ret;
-       const struct ldb_control *partition_ctrl;
-       const struct dsdb_control_current_partition *partition;
 
        ldb = ldb_module_get_ctx(module);
 
@@ -90,31 +88,19 @@ static int instancetype_add(struct ldb_module *module, struct ldb_request *req)
        }
 
        if (ldb_msg_find_element(req->op.add.message, "instanceType")) {
+               unsigned int instanceType = ldb_msg_find_attr_as_uint(req->op.add.message, "instanceType", 0);
+
+               if (instanceType & INSTANCE_TYPE_IS_NC_HEAD) {
+                       /* Do something in future */
+               }
+               
                /* TODO: we need to validate and possibly create a new
                   partition */
                return ldb_next_request(module, req);           
        }
 
-       partition_ctrl = ldb_request_get_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID);
-       if (!partition_ctrl) {
-               ldb_debug_set(ldb, LDB_DEBUG_FATAL,
-                             "instancetype_add: no current partition control found");
-               return LDB_ERR_CONSTRAINT_VIOLATION;
-       }
-
-       partition = talloc_get_type(partition_ctrl->data,
-                                   struct dsdb_control_current_partition);
-       SMB_ASSERT(partition && partition->version == DSDB_CONTROL_CURRENT_PARTITION_VERSION);
-
-       ac = talloc(req, struct it_context);
-       if (ac == NULL) {
-               return LDB_ERR_OPERATIONS_ERROR;
-       }
-       ac->module = module;
-       ac->req = req;
-
        /* we have to copy the message as the caller might have it as a const */
-       msg = ldb_msg_copy_shallow(ac, req->op.add.message);
+       msg = ldb_msg_copy_shallow(req, req->op.add.message);
        if (msg == NULL) {
                ldb_oom(ldb);
                return LDB_ERR_OPERATIONS_ERROR;
@@ -124,12 +110,6 @@ static int instancetype_add(struct ldb_module *module, struct ldb_request *req)
         * TODO: calculate correct instance type
         */
        instance_type = INSTANCE_TYPE_WRITE;
-       if (ldb_dn_compare(partition->dn, msg->dn) == 0) {
-               instance_type |= INSTANCE_TYPE_IS_NC_HEAD;
-               if (ldb_dn_compare(msg->dn, samdb_base_dn(ldb)) != 0) {
-                       instance_type |= INSTANCE_TYPE_NC_ABOVE;
-               }
-       }
 
        ret = ldb_msg_add_fmt(msg, "instanceType", "%u", instance_type);
        if (ret != LDB_SUCCESS) {
@@ -137,10 +117,10 @@ static int instancetype_add(struct ldb_module *module, struct ldb_request *req)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ret = ldb_build_add_req(&down_req, ldb, ac,
+       ret = ldb_build_add_req(&down_req, ldb, req,
                                msg,
                                req->controls,
-                               ac, it_callback,
+                               req->context, req->callback,
                                req);
        if (ret != LDB_SUCCESS) {
                return ret;

diff --git a/source4/dsdb/samdb/ldb_modules/kludge_acl.c b/source4/dsdb/samdb/ldb_modules/kludge_acl.c
index 34f848de8a4899d8fcd461429ef5dc9a869a081c..79309e82bf7b23ee90afdeda96bb5e2caf454939 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/kludge_acl.c
+++ b/source4/dsdb/samdb/ldb_modules/kludge_acl.c
@@ -379,7 +379,7 @@ static int kludge_acl_search(struct ldb_module *module, struct ldb_request *req)
                                        ac, kludge_acl_callback,
                                        req);
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        /* check if there's an SD_FLAGS control */

diff --git a/source4/dsdb/samdb/ldb_modules/lazy_commit.c b/source4/dsdb/samdb/ldb_modules/lazy_commit.c
new file mode 100644 (file)
index 0000000..69ac99e
--- /dev/null
+++ b/source4/dsdb/samdb/ldb_modules/lazy_commit.c
@@ -0,0 +1,132 @@
+/* 
+   ldb database library
+
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
+
+   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/>.
+*/
+
+/*
+ *  Name: ldb
+ *
+ *  Component: ldb lazy_commit module
+ *
+ *  Description: module to pretend to support the 'lazy commit' control
+ *
+ *  Author: Andrew Bartlett
+ */
+
+#include "ldb_module.h"
+
+static int unlazy_op(struct ldb_module *module, struct ldb_request *req)
+{
+       int ret;
+       struct ldb_request *new_req;
+       struct ldb_control **saved_controls;
+       struct ldb_control *control = ldb_request_get_control(req, LDB_CONTROL_SERVER_LAZY_COMMIT);
+       if (!control) {
+               return ldb_next_request(module, req);
+       } 
+       
+       switch (req->operation) {
+       case LDB_SEARCH:
+               ret = ldb_build_search_req_ex(&new_req, ldb_module_get_ctx(module),
+                                             req,
+                                             req->op.search.base,
+                                             req->op.search.scope,
+                                             req->op.search.tree,
+                                             req->op.search.attrs,
+                                             req->controls,
+                                             req->context, req->callback,
+                                             req);
+               break;
+       case LDB_ADD:
+               ret = ldb_build_add_req(&new_req, ldb_module_get_ctx(module), req,
+                                       req->op.add.message,
+                                       req->controls,
+                                       req->context, req->callback,
+                                       req);
+               break;
+       case LDB_MODIFY:
+               ret = ldb_build_mod_req(&new_req, ldb_module_get_ctx(module), req,
+                                       req->op.mod.message,
+                                       req->controls,
+                                       req->context, req->callback,
+                                       req);
+               break;
+       case LDB_DELETE:
+               ret = ldb_build_del_req(&new_req, ldb_module_get_ctx(module), req,
+                                       req->op.del.dn,
+                                       req->controls,
+                                       req->context, req->callback,
+                                       req);
+               break;
+       case LDB_RENAME:
+               ret = ldb_build_rename_req(&new_req, ldb_module_get_ctx(module), req,
+                                          req->op.rename.olddn,
+                                          req->op.rename.newdn,
+                                          req->controls,
+                                          req->context, req->callback,
+                                          req);
+               break;
+       case LDB_EXTENDED:
+               ret = ldb_build_extended_req(&new_req, ldb_module_get_ctx(module),
+                                            req,
+                                            req->op.extended.oid,
+                                            req->op.extended.data,
+                                            req->controls,
+                                            req->context, req->callback,
+                                            req);
+               break;
+       default:
+               ldb_set_errstring(ldb_module_get_ctx(module),
+                                 "Unsupported request type!");
+               ret = LDB_ERR_UNWILLING_TO_PERFORM;
+       }
+
+       if (ret != LDB_SUCCESS) {
+               return ret;
+       }
+
+       save_controls(control, req, &saved_controls);
+       return ldb_next_request(module, new_req);
+}
+
+static int unlazy_init(struct ldb_module *module)
+{
+       int ret;
+       struct ldb_context *ldb;
+       ldb = ldb_module_get_ctx(module);
+
+       ret = ldb_mod_register_control(module, LDB_CONTROL_SHOW_DELETED_OID);
+       if (ret != LDB_SUCCESS) {
+               ldb_debug(ldb, LDB_DEBUG_ERROR,
+                       "lazy_commit: Unable to register control with rootdse!\n");
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
+       return ldb_next_init(module);
+}
+
+const struct ldb_module_ops ldb_lazy_commit_module_ops = {
+       .name              = "lazy_commit",
+       .search            = unlazy_op,
+       .add               = unlazy_op,
+       .modify            = unlazy_op,
+       .del               = unlazy_op,
+       .rename            = unlazy_op,
+       .request           = unlazy_op,
+       .extended          = unlazy_op,
+       .init_context      = unlazy_init,
+};

diff --git a/source4/dsdb/samdb/ldb_modules/local_password.c b/source4/dsdb/samdb/ldb_modules/local_password.c
index 58c0f1f0d522c63da18d4c43d59feb342e306c88..9c386b354d428385a440240eecce05a28cf8946b 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/local_password.c
+++ b/source4/dsdb/samdb/ldb_modules/local_password.c
@@ -633,8 +633,7 @@ static int lpdb_delete_callabck(struct ldb_request *req,
 
        ret = ldb_next_request(ac->module, search_req);
        if (ret != LDB_SUCCESS) {
-               return ldb_module_done(ac->req, NULL, NULL,
-                                       LDB_ERR_OPERATIONS_ERROR);
+               return ldb_module_done(ac->req, NULL, NULL, ret);
        }
        return LDB_SUCCESS;
 }
@@ -1082,7 +1081,7 @@ static int local_password_search(struct ldb_module *module, struct ldb_request *
                                        ac, lpdb_remote_search_callback,
                                        req);
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        /* perform the search */

diff --git a/source4/dsdb/samdb/ldb_modules/naming_fsmo.c b/source4/dsdb/samdb/ldb_modules/naming_fsmo.c
index 607bf054d22c319aa6858a9f5cb56e99d5d221c7..15cad259ce8eea2173062fa69f115e1708130089 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/naming_fsmo.c
+++ b/source4/dsdb/samdb/ldb_modules/naming_fsmo.c
@@ -28,6 +28,7 @@
 #include "librpc/gen_ndr/ndr_drsuapi.h"
 #include "librpc/gen_ndr/ndr_drsblobs.h"
 #include "../lib/util/dlinklist.h"
+#include "dsdb/samdb/ldb_modules/util.h"
 
 static int naming_fsmo_init(struct ldb_module *module)
 {
@@ -65,34 +66,15 @@ static int naming_fsmo_init(struct ldb_module *module)
        }
        ldb_module_set_private(module, naming_fsmo);
 
-       ret = ldb_search(ldb, mem_ctx, &naming_res,
-                        naming_dn, LDB_SCOPE_BASE,
-                        naming_attrs, NULL);
+       ret = dsdb_module_search_dn(module, mem_ctx, &naming_res,
+                                   naming_dn, 
+                                   naming_attrs);
        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                ldb_debug(ldb, LDB_DEBUG_WARNING,
                          "naming_fsmo_init: no partitions dn present: (skip loading of naming contexts details)\n");
                talloc_free(mem_ctx);
                return ldb_next_init(module);
        }
-       if (ret != LDB_SUCCESS) {
-               ldb_debug_set(ldb, LDB_DEBUG_FATAL,
-                             "naming_fsmo_init: failed to search the cross-ref container: %s: %s",
-                             ldb_strerror(ret), ldb_errstring(ldb));
-               talloc_free(mem_ctx);
-               return ret;
-       }
-       if (naming_res->count == 0) {
-               ldb_debug(ldb, LDB_DEBUG_WARNING,
-                         "naming_fsmo_init: no cross-ref container present: (skip loading of naming contexts details)\n");
-               talloc_free(mem_ctx);
-               return ldb_next_init(module);
-       } else if (naming_res->count > 1) {
-               ldb_debug_set(ldb, LDB_DEBUG_FATAL,
-                             "naming_fsmo_init: [%u] cross-ref containers found on a base search",
-                             naming_res->count);
-               talloc_free(mem_ctx);
-               return LDB_ERR_CONSTRAINT_VIOLATION;
-       }
 
        naming_fsmo->master_dn = ldb_msg_find_attr_as_dn(ldb, naming_fsmo, naming_res->msgs[0], "fSMORoleOwner");
        if (ldb_dn_compare(samdb_ntds_settings_dn(ldb), naming_fsmo->master_dn) == 0) {

diff --git a/source4/dsdb/samdb/ldb_modules/objectclass.c b/source4/dsdb/samdb/ldb_modules/objectclass.c
index 3cf252c71a8872dbda4efc5a68b5c7a01a3cadd7..003d6731d4b37c67d8a7cf89d647c02e1bf633c3 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/objectclass.c
+++ b/source4/dsdb/samdb/ldb_modules/objectclass.c
@@ -2,7 +2,7 @@
    ldb database library
 
    Copyright (C) Simo Sorce  2006-2008
-   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2007
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2009
 
    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
@@ -42,6 +42,7 @@
 #include "libcli/security/security.h"
 #include "auth/auth.h"
 #include "param/param.h"
+#include "../libds/common/flags.h"
 
 struct oc_context {
 
@@ -138,7 +139,13 @@ static int objectclass_sort(struct ldb_module *module,
                if (!current->objectclass) {
                        ldb_asprintf_errstring(ldb, "objectclass %.*s is not a valid objectClass in schema", 
                                               (int)objectclass_element->values[i].length, (const char *)objectclass_element->values[i].data);
-                       return LDB_ERR_OBJECT_CLASS_VIOLATION;
+                       /* This looks weird, but windows apparently returns this for invalid objectClass values */
+                       return LDB_ERR_NO_SUCH_ATTRIBUTE;
+               } else if (current->objectclass->isDefunct) {
+                       ldb_asprintf_errstring(ldb, "objectclass %.*s marked as isDefunct objectClass in schema - not valid for new objects", 
+                                              (int)objectclass_element->values[i].length, (const char *)objectclass_element->values[i].data);
+                       /* This looks weird, but windows apparently returns this for invalid objectClass values */
+                       return LDB_ERR_NO_SUCH_ATTRIBUTE;
                }
 
                /* this is the root of the tree.  We will start
@@ -323,6 +330,8 @@ static int fix_dn(TALLOC_CTX *mem_ctx,
                  struct ldb_dn **fixed_dn) 
 {
        char *upper_rdn_attr;
+       const struct ldb_val *rdn_val;
+
        /* Fix up the DN to be in the standard form, taking particular care to match the parent DN */
        *fixed_dn = ldb_dn_copy(mem_ctx, parent_dn);
 
@@ -332,15 +341,21 @@ static int fix_dn(TALLOC_CTX *mem_ctx,
        if (!upper_rdn_attr) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
-                                              
+
        /* Create a new child */
        if (ldb_dn_add_child_fmt(*fixed_dn, "X=X") == false) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
+       /* AD doesn't allow the rDN to be longer than 64 characters */
+       rdn_val = ldb_dn_get_rdn_val(newdn);
+       if (!rdn_val || rdn_val->length > 64) {
+               DEBUG(2,(__location__ ": rDN longer than 64 limit for '%s'\n", ldb_dn_get_linearized(newdn)));
+               return LDB_ERR_CONSTRAINT_VIOLATION;
+       }
+
        /* And replace it with CN=foo (we need the attribute in upper case */
-       return ldb_dn_set_component(*fixed_dn, 0, upper_rdn_attr,
-                                   *ldb_dn_get_rdn_val(newdn));
+       return ldb_dn_set_component(*fixed_dn, 0, upper_rdn_attr, *rdn_val);
 }
 
 /* Fix all attribute names to be in the correct case, and check they are all valid per the schema */
@@ -355,7 +370,8 @@ static int fix_attributes(struct ldb_context *ldb, const struct dsdb_schema *sch
                if (!attribute) {
                        if (strcasecmp(msg->elements[i].name, "clearTextPassword") != 0) {
                                ldb_asprintf_errstring(ldb, "attribute %s is not a valid attribute in schema", msg->elements[i].name);
-                               return LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE;
+                               /* Apparently Windows sends exactly this behaviour */
+                               return LDB_ERR_NO_SUCH_ATTRIBUTE;
                        }
                } else {
                        msg->elements[i].name = attribute->lDAPDisplayName;
@@ -374,7 +390,7 @@ static int objectclass_add(struct ldb_module *module, struct ldb_request *req)
        struct oc_context *ac;
        struct ldb_dn *parent_dn;
        int ret;
-       static const char * const parent_attrs[] = { "objectGUID", NULL };
+       static const char * const parent_attrs[] = { "objectGUID", "objectClass", NULL };
 
        ldb = ldb_module_get_ctx(module);
 
@@ -458,7 +474,7 @@ static int objectclass_do_add(struct oc_context *ac)
                        ldb_asprintf_errstring(ldb, "objectclass: Cannot add %s, parent does not exist!", 
                                               ldb_dn_get_linearized(msg->dn));
                        talloc_free(mem_ctx);
-                       return LDB_ERR_UNWILLING_TO_PERFORM;
+                       return LDB_ERR_NO_SUCH_OBJECT;
                }
        } else {
                const struct ldb_val *parent_guid;
@@ -484,9 +500,6 @@ static int objectclass_do_add(struct oc_context *ac)
                        return LDB_ERR_UNWILLING_TO_PERFORM;                    
                }
 
-               /* TODO: Check this is a valid child to this parent,
-                * by reading the allowedChildClasses and
-                * allowedChildClasssesEffective attributes */
                ret = ldb_msg_add_steal_value(msg, "parentGUID", discard_const(parent_guid));
                if (ret != LDB_SUCCESS) {
                        ldb_asprintf_errstring(ldb, "objectclass: Cannot add %s, failed to add parentGUID", 
@@ -547,7 +560,59 @@ static int objectclass_do_add(struct oc_context *ac)
                        if (!current->next) {
                                struct ldb_message_element *el;
                                int32_t systemFlags = 0;
-                               DATA_BLOB *sd;
+                               const char *rdn_name = ldb_dn_get_rdn_name(msg->dn);
+                               if (current->objectclass->rDNAttID
+                                   && ldb_attr_cmp(rdn_name, current->objectclass->rDNAttID) != 0) {
+                                       ldb_asprintf_errstring(ldb,
+                                                              "RDN %s is not correct for most specific structural objectclass %s, should be %s",
+                                                              rdn_name, current->objectclass->lDAPDisplayName, current->objectclass->rDNAttID);
+                                       return LDB_ERR_NAMING_VIOLATION;
+                               }
+
+                               if (ac->search_res && ac->search_res->message) {
+                                       struct ldb_message_element *oc_el
+                                               = ldb_msg_find_element(ac->search_res->message, "objectClass");
+
+                                       bool allowed_class = false;
+                                       int i, j;
+                                       for (i=0; allowed_class == false && oc_el && i < oc_el->num_values; i++) {
+                                               const struct dsdb_class *sclass;
+
+                                               sclass = dsdb_class_by_lDAPDisplayName_ldb_val(schema, &oc_el->values[i]);
+                                               if (!sclass) {
+                                                       /* We don't know this class?  what is going on? */
+                                                       continue;
+                                               }
+                                               if (ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID)) {
+                                                       for (j=0; sclass->systemPossibleInferiors && sclass->systemPossibleInferiors[j]; j++) {
+                                                               if (ldb_attr_cmp(current->objectclass->lDAPDisplayName, sclass->systemPossibleInferiors[j]) == 0) {
+                                                                       allowed_class = true;
+                                                                       break;
+                                                               }
+                                                       }
+                                               } else {
+                                                       for (j=0; sclass->systemPossibleInferiors && sclass->systemPossibleInferiors[j]; j++) {
+                                                               if (ldb_attr_cmp(current->objectclass->lDAPDisplayName, sclass->systemPossibleInferiors[j]) == 0) {
+                                                                       allowed_class = true;
+                                                                       break;
+                                                               }
+                                                       }
+                                               }
+                                       }
+
+                                       if (!allowed_class) {
+                                               ldb_asprintf_errstring(ldb, "structural objectClass %s is not a valid child class for %s",
+                                                              current->objectclass->lDAPDisplayName, ldb_dn_get_linearized(ac->search_res->message->dn));
+                                               return LDB_ERR_NAMING_VIOLATION;
+                                       }
+                               }
+
+                               if (current->objectclass->systemOnly && !ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID)) {
+                                       ldb_asprintf_errstring(ldb, "objectClass %s is systemOnly, rejecting creation of %s",
+                                                              current->objectclass->lDAPDisplayName, ldb_dn_get_linearized(msg->dn));
+                                       return LDB_ERR_UNWILLING_TO_PERFORM;
+                               }
+
                                if (!ldb_msg_find_element(msg, "objectCategory")) {
                                        value = talloc_strdup(msg, current->objectclass->defaultObjectCategory);
                                        if (value == NULL) {
@@ -649,7 +714,13 @@ static int objectclass_modify(struct ldb_module *module, struct ldb_request *req
        if (!schema) {
                return ldb_next_request(module, req);
        }
-       objectclass_element = ldb_msg_find_element(req->op.mod.message, "objectClass");
+
+       /* As with the "real" AD we don't accept empty messages */
+       if (req->op.mod.message->num_elements == 0) {
+               ldb_set_errstring(ldb, "objectclass: modify message must have "
+                                      "elements/attributes!");
+               return LDB_ERR_UNWILLING_TO_PERFORM;
+       }
 
        ac = oc_init_context(module, req);
        if (ac == NULL) {
@@ -658,6 +729,7 @@ static int objectclass_modify(struct ldb_module *module, struct ldb_request *req
 
        /* If no part of this touches the objectClass, then we don't
         * need to make any changes.  */
+       objectclass_element = ldb_msg_find_element(req->op.mod.message, "objectClass");
 
        /* If the only operation is the deletion of the objectClass
         * then go on with just fixing the attribute case */
@@ -824,6 +896,8 @@ static int oc_modify_callback(struct ldb_request *req, struct ldb_reply *ares)
                                        LDB_ERR_OPERATIONS_ERROR);
        }
 
+       talloc_free(ares);
+
        ret = ldb_build_search_req(&search_req, ldb, ac,
                                   ac->req->op.mod.message->dn, LDB_SCOPE_BASE,
                                   "(objectClass=*)",
@@ -1032,6 +1106,7 @@ static int objectclass_rename_callback(struct ldb_request *req, struct ldb_reply
                                        ares->response, ares->error);
        }
 
+       talloc_free(ares);
 
        /* the ac->search_res should contain the new parents objectGUID */
        parent_guid = ldb_msg_find_ldb_val(ac->search_res->message, "objectGUID");

diff --git a/source4/dsdb/samdb/ldb_modules/objectguid.c b/source4/dsdb/samdb/ldb_modules/objectguid.c
index 3d218edc767bd75b4d4a6ff9f10e02bf68634bad..12dd402617205a12fde9cf0cd746ba4b885ac262 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/objectguid.c
+++ b/source4/dsdb/samdb/ldb_modules/objectguid.c
@@ -209,7 +209,7 @@ static int objectguid_add(struct ldb_module *module, struct ldb_request *req)
                                ac, og_op_callback,
                                req);
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        /* go on with the call chain */
@@ -267,7 +267,7 @@ static int objectguid_modify(struct ldb_module *module, struct ldb_request *req)
                                ac, og_op_callback,
                                req);
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        /* go on with the call chain */

diff --git a/source4/dsdb/samdb/ldb_modules/partition.c b/source4/dsdb/samdb/ldb_modules/partition.c
index 6e86d4c48455310477e7dbd0f9d5986e20b8c861..c5bbdf8dce35b9c3fff78735026797b6ed5bd887 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/partition.c
+++ b/source4/dsdb/samdb/ldb_modules/partition.c
@@ -829,14 +829,22 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
                                             res,
                                             ldb_extended_default_callback,
                                             NULL);
-               ret = ldb_next_request(module, treq);
-               if (ret == LDB_SUCCESS) {
-                       ret = ldb_wait(treq->handle, LDB_WAIT_ALL);
+               if (ret != LDB_SUCCESS) {
+                       talloc_free(res);
+                       return ret;
                }
+
+               ret = ldb_next_request(module, treq);
                if (ret != LDB_SUCCESS) {
                        talloc_free(res);
                        return ret;
                }
+               ret = ldb_wait(treq->handle, LDB_WAIT_ALL);
+               if (ret != LDB_SUCCESS) {
+                       talloc_free(res);
+                       return ret;
+               }
+
                seqr = talloc_get_type(res->extended->data,
                                        struct ldb_seqnum_result);
                if (seqr->flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
@@ -1083,7 +1091,7 @@ static int partition_extended_schema_update_now(struct ldb_module *module, struc
        }
 
        /* fire the first one */
-       ret =  partition_call_first(ac);
+       ret = partition_call_first(ac);
 
        if (ret != LDB_SUCCESS){
                return ret;
@@ -1385,14 +1393,14 @@ static int partition_init(struct ldb_module *module)
        if (ret != LDB_SUCCESS) {
                ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
                        "partition: Unable to register control with rootdse!\n");
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
        if (ret != LDB_SUCCESS) {
                ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
                        "partition: Unable to register control with rootdse!\n");
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        talloc_free(mem_ctx);

diff --git a/source4/dsdb/samdb/ldb_modules/password_hash.c b/source4/dsdb/samdb/ldb_modules/password_hash.c
index fdb044198bef78c79b3e02ae5ace7b2e6851bc69..a3c99f42227efd2cade1e47528f9fe4d24b444a5 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/password_hash.c
+++ b/source4/dsdb/samdb/ldb_modules/password_hash.c
@@ -87,9 +87,9 @@ struct domain_data {
        bool store_cleartext;
        uint_t pwdProperties;
        uint_t pwdHistoryLength;
-       char *netbios_domain;
-       char *dns_domain;
-       char *realm;
+       const char *netbios_domain;
+       const char *dns_domain;
+       const char *realm;
 };
 
 struct setup_password_fields_io {
@@ -1552,9 +1552,8 @@ static int get_domain_data_callback(struct ldb_request *req,
        struct ldb_context *ldb;
        struct domain_data *data;
        struct ph_context *ac;
+       struct loadparm_context *lp_ctx;
        int ret;
-       char *tmp;
-       char *p;
 
        ac = talloc_get_type(req->context, struct ph_context);
        ldb = ldb_module_get_ctx(ac->module);
@@ -1591,43 +1590,13 @@ static int get_domain_data_callback(struct ldb_request *req,
                 * but that doesn't really matter, as it's just used for salt
                 * and kerberos principals, which don't exist here */
 
-               tmp = ldb_dn_canonical_string(data, ares->message->dn);
-               if (!tmp) {
-                       return ldb_module_done(ac->req, NULL, NULL,
-                                               LDB_ERR_OPERATIONS_ERROR);
-               }
+               lp_ctx = talloc_get_type(ldb_get_opaque(ldb, "loadparm"),
+                                        struct loadparm_context);
 
-               /* But it puts a trailing (or just before 'builtin') / on things, so kill that */
-               p = strchr(tmp, '/');
-               if (p) {
-                       p[0] = '\0';
-               }
-
-               data->dns_domain = strlower_talloc(data, tmp);
-               if (data->dns_domain == NULL) {
-                       ldb_oom(ldb);
-                       return ldb_module_done(ac->req, NULL, NULL,
-                                               LDB_ERR_OPERATIONS_ERROR);
-               }
-               data->realm = strupper_talloc(data, tmp);
-               if (data->realm == NULL) {
-                       ldb_oom(ldb);
-                       return ldb_module_done(ac->req, NULL, NULL,
-                                               LDB_ERR_OPERATIONS_ERROR);
-               }
-               /* FIXME: NetbIOS name is *always* the first domain component ?? -SSS */
-               p = strchr(tmp, '.');
-               if (p) {
-                       p[0] = '\0';
-               }
-               data->netbios_domain = strupper_talloc(data, tmp);
-               if (data->netbios_domain == NULL) {
-                       ldb_oom(ldb);
-                       return ldb_module_done(ac->req, NULL, NULL,
-                                               LDB_ERR_OPERATIONS_ERROR);
-               }
+               data->dns_domain = lp_dnsdomain(lp_ctx);
+               data->realm = lp_realm(lp_ctx);
+               data->netbios_domain = lp_workgroup(lp_ctx);
 
-               talloc_free(tmp);
                ac->domain = data;
                break;
 
@@ -1673,7 +1642,7 @@ static int build_domain_data_request(struct ph_context *ac)
        ldb = ldb_module_get_ctx(ac->module);
 
        filter = talloc_asprintf(ac,
-                               "(&(objectSid=%s)(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain)))",
+                                "(objectSid=%s)",
                                 ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
        if (filter == NULL) {
                ldb_oom(ldb);
@@ -1682,7 +1651,7 @@ static int build_domain_data_request(struct ph_context *ac)
 
        return ldb_build_search_req(&ac->dom_req, ldb, ac,
                                    ldb_get_default_basedn(ldb),
-                                   LDB_SCOPE_SUBTREE,
+                                   LDB_SCOPE_BASE,
                                    filter, attrs,
                                    NULL,
                                    ac, get_domain_data_callback,

diff --git a/source4/dsdb/samdb/ldb_modules/pdc_fsmo.c b/source4/dsdb/samdb/ldb_modules/pdc_fsmo.c
index 950f87eb74817f4532637b9c0123ac0e0ca2de52..6d814f9334f0e03661ef550898f12433ca331b62 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/pdc_fsmo.c
+++ b/source4/dsdb/samdb/ldb_modules/pdc_fsmo.c
@@ -27,6 +27,7 @@
 #include "librpc/gen_ndr/ndr_drsuapi.h"
 #include "librpc/gen_ndr/ndr_drsblobs.h"
 #include "../lib/util/dlinklist.h"
+#include "dsdb/samdb/ldb_modules/util.h"
 
 static int pdc_fsmo_init(struct ldb_module *module)
 {
@@ -64,9 +65,9 @@ static int pdc_fsmo_init(struct ldb_module *module)
        }
        ldb_module_set_private(module, pdc_fsmo);
 
-       ret = ldb_search(ldb, mem_ctx, &pdc_res,
-                        pdc_dn, LDB_SCOPE_BASE,
-                        pdc_attrs, NULL);
+       ret = dsdb_module_search_dn(module, mem_ctx, &pdc_res,
+                                   pdc_dn, 
+                                   pdc_attrs);
        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                ldb_debug(ldb, LDB_DEBUG_WARNING,
                          "pdc_fsmo_init: no domain object present: (skip loading of domain details)\n");
@@ -79,19 +80,6 @@ static int pdc_fsmo_init(struct ldb_module *module)
                talloc_free(mem_ctx);
                return ret;
        }
-       if (pdc_res->count == 0) {
-               ldb_debug(ldb, LDB_DEBUG_WARNING,
-                         "pdc_fsmo_init: no domain object present: (skip loading of domain details)\n");
-               talloc_free(mem_ctx);
-               return ldb_next_init(module);
-       } else if (pdc_res->count > 1) {
-               ldb_debug_set(ldb, LDB_DEBUG_FATAL,
-                             "pdc_fsmo_init: [%u] domain objects found on a base search",
-                             pdc_res->count);
-               DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
-               talloc_free(mem_ctx);
-               return LDB_ERR_CONSTRAINT_VIOLATION;
-       }
 
        pdc_fsmo->master_dn = ldb_msg_find_attr_as_dn(ldb, mem_ctx, pdc_res->msgs[0], "fSMORoleOwner");
        if (ldb_dn_compare(samdb_ntds_settings_dn(ldb), pdc_fsmo->master_dn) == 0) {

diff --git a/source4/dsdb/samdb/ldb_modules/repl_meta_data.c b/source4/dsdb/samdb/ldb_modules/repl_meta_data.c
index 253596ddeac5cca053eb0b76a6b09840470f1796..74dd7e5bbb34517056cfe7be028d48e3659acc3a 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/repl_meta_data.c
+++ b/source4/dsdb/samdb/ldb_modules/repl_meta_data.c
@@ -457,11 +457,14 @@ static int replmd_op_callback(struct ldb_request *req, struct ldb_reply *ares)
 static int replmd_add(struct ldb_module *module, struct ldb_request *req)
 {
        struct ldb_context *ldb;
+        struct ldb_control *control;
+        struct ldb_control **saved_controls;
        struct replmd_replicated_request *ac;
        const struct dsdb_schema *schema;
        enum ndr_err_code ndr_err;
        struct ldb_request *down_req;
        struct ldb_message *msg;
+        const DATA_BLOB *guid_blob;
        struct GUID guid;
        struct ldb_val guid_value;
        struct replPropertyMetaDataBlob nmd;
@@ -473,6 +476,14 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
        char *time_str;
        int ret;
        uint32_t i, ni=0;
+       bool allow_add_guid = false;
+       bool remove_current_guid = false;
+
+        /* check if there's a show relax control (used by provision to say 'I know what I'm doing') */
+        control = ldb_request_get_control(req, LDB_CONTROL_RELAX_OID);
+       if (control) {
+               allow_add_guid = 1;
+       }
 
        /* do not manipulate our control entries */
        if (ldb_dn_is_special(req->op.add.message->dn)) {
@@ -498,26 +509,43 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
 
        ac->schema = schema;
 
-       if (ldb_msg_find_element(req->op.add.message, "objectGUID") != NULL) {
-               ldb_debug_set(ldb, LDB_DEBUG_ERROR,
+        guid_blob = ldb_msg_find_ldb_val(req->op.add.message, "objectGUID");
+       if ( guid_blob != NULL ) {
+               if( !allow_add_guid ) {
+                       ldb_debug_set(ldb, LDB_DEBUG_ERROR,
                              "replmd_add: it's not allowed to add an object with objectGUID\n");
-               return LDB_ERR_UNWILLING_TO_PERFORM;
+                       talloc_free(ac);
+                       return LDB_ERR_UNWILLING_TO_PERFORM;
+               } else {
+                       NTSTATUS status = GUID_from_data_blob(guid_blob,&guid);
+                       if ( !NT_STATUS_IS_OK(status)) {
+                                       ldb_debug_set(ldb, LDB_DEBUG_ERROR,
+                                     "replmd_add: Unable to parse as a GUID the attribute objectGUID\n");
+                               talloc_free(ac);
+                               return LDB_ERR_UNWILLING_TO_PERFORM;
+                       }
+                       /* we remove this attribute as it can be a string and will not be treated 
+                       correctly and then we will readd it latter on in the good format*/
+                       remove_current_guid = true;
+               }
+       } else {
+               /* a new GUID */
+               guid = GUID_random();
        }
 
        /* Get a sequence number from the backend */
        ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
        if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
                return ret;
        }
 
-       /* a new GUID */
-       guid = GUID_random();
-
        /* get our invocationId */
        our_invocation_id = samdb_ntds_invocation_id(ldb);
        if (!our_invocation_id) {
                ldb_debug_set(ldb, LDB_DEBUG_ERROR,
                              "replmd_add: unable to find invocationId\n");
+               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -525,6 +553,7 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
        msg = ldb_msg_copy_shallow(ac, req->op.add.message);
        if (msg == NULL) {
                ldb_oom(ldb);
+               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -532,8 +561,13 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
        unix_to_nt_time(&now, t);
        time_str = ldb_timestring(msg, t);
        if (!time_str) {
+               ldb_oom(ldb);
+               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
+       if (remove_current_guid) {
+               ldb_msg_remove_attr(msg,"objectGUID");
+       }
 
        /* 
         * remove autogenerated attributes
@@ -548,7 +582,8 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
                ret = ldb_msg_add_fmt(msg, "instanceType", "%u", INSTANCE_TYPE_WRITE);
                if (ret != LDB_SUCCESS) {
                        ldb_oom(ldb);
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       talloc_free(ac);
+                       return ret;
                }
        }
 
@@ -558,7 +593,8 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
        ret = ldb_msg_add_string(msg, "whenCreated", time_str);
        if (ret != LDB_SUCCESS) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               talloc_free(ac);
+               return ret;
        }
 
        /* build the replication meta_data */
@@ -570,6 +606,7 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
                                               nmd.ctr.ctr1.count);
        if (!nmd.ctr.ctr1.array) {
                ldb_oom(ldb);
+               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -585,6 +622,7 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
                        ldb_debug_set(ldb, LDB_DEBUG_ERROR,
                                      "replmd_add: attribute '%s' not defined in schema\n",
                                      e->name);
+                       talloc_free(ac);
                        return LDB_ERR_NO_SUCH_ATTRIBUTE;
                }
 
@@ -612,6 +650,7 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
         */
        ret = replmd_replPropertyMetaDataCtr1_sort(&nmd.ctr.ctr1, schema, msg->dn);
        if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
                return ret;
        }
 
@@ -622,6 +661,7 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
                                       (ndr_push_flags_fn_t)ndr_push_GUID);
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                ldb_oom(ldb);
+               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
        ndr_err = ndr_push_struct_blob(&nmd_value, msg, 
@@ -630,6 +670,7 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
                                       (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                ldb_oom(ldb);
+               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -639,27 +680,32 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
        ret = ldb_msg_add_value(msg, "objectGUID", &guid_value, NULL);
        if (ret != LDB_SUCCESS) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               talloc_free(ac);
+               return ret;
        }
        ret = ldb_msg_add_string(msg, "whenChanged", time_str);
        if (ret != LDB_SUCCESS) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               talloc_free(ac);
+               return ret;
        }
        ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNCreated", seq_num);
        if (ret != LDB_SUCCESS) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               talloc_free(ac);
+               return ret;
        }
        ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
        if (ret != LDB_SUCCESS) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               talloc_free(ac);
+               return ret;
        }
        ret = ldb_msg_add_value(msg, "replPropertyMetaData", &nmd_value, NULL);
        if (ret != LDB_SUCCESS) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               talloc_free(ac);
+               return ret;
        }
 
        /*
@@ -673,14 +719,22 @@ static int replmd_add(struct ldb_module *module, struct ldb_request *req)
                                ac, replmd_op_callback,
                                req);
        if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
                return ret;
        }
 
        ret = replmd_notify(module, msg->dn, seq_num);
        if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
                return ret;
        }
 
+               /* if a control is there remove if from the modified request */
+       if (control && !save_controls(control, down_req, &saved_controls)) {
+               talloc_free(ac);
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
        /* go on with the call chain */
        return ldb_next_request(module, down_req);
 }
@@ -785,7 +839,7 @@ static int replmd_update_rpmd(struct ldb_module *module,
 
        /* search for the existing replPropertyMetaDataBlob */
        ret = dsdb_search_dn_with_deleted(ldb, msg, &res, msg->dn, attrs);
-       if (ret != LDB_SUCCESS || res->count < 1) {
+       if (ret != LDB_SUCCESS || res->count != 1) {
                DEBUG(0,(__location__ ": Object %s failed to find replPropertyMetaData\n",
                         ldb_dn_get_linearized(msg->dn)));
                return LDB_ERR_OPERATIONS_ERROR;
@@ -880,9 +934,10 @@ static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
        const struct dsdb_schema *schema;
        struct ldb_request *down_req;
        struct ldb_message *msg;
-       int ret;
+       struct ldb_result *res;
        time_t t = time(NULL);
        uint64_t seq_num = 0;
+       int ret;
 
        /* do not manipulate our control entries */
        if (ldb_dn_is_special(req->op.mod.message->dn)) {
@@ -911,13 +966,12 @@ static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
        /* we have to copy the message as the caller might have it as a const */
        msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
        if (msg == NULL) {
+               ldb_oom(ldb);
                talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
        /* TODO:
-        * - get the whole old object
-        * - if the old object doesn't exist report an error
         * - give an error when a readonly attribute should
         *   be modified
         * - merge the changed into the old object
@@ -926,8 +980,15 @@ static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
         *   attribute was changed
         */
 
+       ret = dsdb_search_dn_with_deleted(ldb, msg, &res, msg->dn, NULL);
+       if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
+               return ret;
+       }
+
        ret = replmd_update_rpmd(module, msg, &seq_num);
        if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
                return ret;
        }
 
@@ -941,6 +1002,7 @@ static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
                                ac, replmd_op_callback,
                                req);
        if (ret != LDB_SUCCESS) {
+               talloc_free(ac);
                return ret;
        }
        talloc_steal(down_req, msg);
@@ -950,12 +1012,12 @@ static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
        if (seq_num != 0) {
                if (add_time_element(msg, "whenChanged", t) != LDB_SUCCESS) {
                        talloc_free(ac);
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       return ret;
                }
 
                if (add_uint64_element(msg, "uSNChanged", seq_num) != LDB_SUCCESS) {
                        talloc_free(ac);
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       return ret;
                }
        }
 

diff --git a/source4/dsdb/samdb/ldb_modules/rootdse.c b/source4/dsdb/samdb/ldb_modules/rootdse.c
index a8e08ec3ad58638d79aa28d264377dd9e9e396c0..83e4e3b50edff38ec6a76c0d249c5b9f2f94ca8f 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/rootdse.c
+++ b/source4/dsdb/samdb/ldb_modules/rootdse.c
@@ -722,9 +722,9 @@ static int rootdse_modify(struct ldb_module *module, struct ldb_request *req)
 }
 
 _PUBLIC_ const struct ldb_module_ops ldb_rootdse_module_ops = {
-       .name                   = "rootdse",
+       .name           = "rootdse",
        .init_context   = rootdse_init,
        .search         = rootdse_search,
-       .request                = rootdse_request,
+       .request        = rootdse_request,
        .modify         = rootdse_modify
 };

diff --git a/source4/dsdb/samdb/ldb_modules/samldb.c b/source4/dsdb/samdb/ldb_modules/samldb.c
index e59b5dd1ce737bd7310e9e94dfcc40059aec2529..2a0bb2dfe668f3949f8c23220af76dae1d77b00b 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/samldb.c
+++ b/source4/dsdb/samdb/ldb_modules/samldb.c
@@ -284,8 +284,7 @@ static int samldb_get_parent_domain(struct samldb_ctx *ac)
        ret = ldb_build_search_req(&req, ldb, ac,
                                   dn, LDB_SCOPE_BASE,
                                   "(|(objectClass=domain)"
-                                    "(objectClass=builtinDomain)"
-                                    "(objectClass=samba4LocalDomain))",
+                                  "(objectClass=builtinDomain))",
                                   attrs,
                                   NULL,
                                   ac, samldb_get_parent_domain_callback,
@@ -559,10 +558,10 @@ static int samldb_get_sid_domain(struct samldb_ctx *ac)
        /* get the domain component part of the provided SID */
        ac->domain_sid->num_auths--;
 
-       filter = talloc_asprintf(ac, "(&(objectSid=%s)"
-                                      "(|(objectClass=domain)"
-                                        "(objectClass=builtinDomain)"
-                                        "(objectClass=samba4LocalDomain)))",
+       filter = talloc_asprintf(ac, 
+                                "(&(objectSid=%s)"
+                                "(|(objectClass=domain)"
+                                "(objectClass=builtinDomain)))",
                                 ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
        if (filter == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;
@@ -699,8 +698,14 @@ static int samldb_check_primaryGroupID_1(struct samldb_ctx *ac)
 
 static int samldb_check_primaryGroupID_2(struct samldb_ctx *ac)
 {
-       if (ac->res_dn == NULL)
+       if (ac->res_dn == NULL) {
+               struct ldb_context *ldb;
+               ldb = ldb_module_get_ctx(ac->module);
+               ldb_asprintf_errstring(ldb,
+                                      "Failed to find group sid %s", 
+                                      dom_sid_string(ac->sid, ac->sid));
                return LDB_ERR_UNWILLING_TO_PERFORM;
+       }
 
        return samldb_next_step(ac);
 }
@@ -1866,7 +1871,7 @@ static int samldb_add(struct ldb_module *module, struct ldb_request *req)
        int ret;
 
        ldb = ldb_module_get_ctx(module);
-       ldb_debug(ldb, LDB_DEBUG_TRACE, "samldb_add_record\n");
+       ldb_debug(ldb, LDB_DEBUG_TRACE, "samldb_add\n");
 
        /* do not manipulate our control entries */
        if (ldb_dn_is_special(req->op.add.message->dn)) {

diff --git a/source4/dsdb/samdb/ldb_modules/schema_fsmo.c b/source4/dsdb/samdb/ldb_modules/schema_fsmo.c
index c482ab57df2a19c844ea2a18d473320616f8b8d4..2b6606c147a58371e572cbc2111df2ed46ff0d15 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/schema_fsmo.c
+++ b/source4/dsdb/samdb/ldb_modules/schema_fsmo.c
@@ -5,6 +5,7 @@
    checkings, it also loads the dsdb_schema.
    
    Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
     
    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
@@ -28,6 +29,7 @@
 #include "librpc/gen_ndr/ndr_drsuapi.h"
 #include "librpc/gen_ndr/ndr_drsblobs.h"
 #include "param/param.h"
+#include "dsdb/samdb/ldb_modules/util.h"
 
 static int generate_objectClasses(struct ldb_context *ldb, struct ldb_message *msg,
                                  const struct dsdb_schema *schema);
@@ -90,13 +92,107 @@ struct schema_fsmo_search_data {
        const struct dsdb_schema *schema;
 };
 
+/*
+  Given an LDB module (pointing at the schema DB), and the DN, set the populated schema
+*/
+
+static int dsdb_schema_from_schema_dn(TALLOC_CTX *mem_ctx, struct ldb_module *module,
+                                     struct smb_iconv_convenience *iconv_convenience, 
+                                     struct ldb_dn *schema_dn,
+                                     struct dsdb_schema **schema) 
+{
+       TALLOC_CTX *tmp_ctx;
+       char *error_string;
+       int ret;
+       struct ldb_context *ldb = ldb_module_get_ctx(module);
+       struct ldb_result *schema_res;
+       struct ldb_result *a_res;
+       struct ldb_result *c_res;
+       static const char *schema_attrs[] = {
+               "prefixMap",
+               "schemaInfo",
+               "fSMORoleOwner",
+               NULL
+       };
+       unsigned flags;
+
+       tmp_ctx = talloc_new(mem_ctx);
+       if (!tmp_ctx) {
+               ldb_oom(ldb);
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
+       /* we don't want to trace the schema load */
+       flags = ldb_get_flags(ldb);
+       ldb_set_flags(ldb, flags & ~LDB_FLG_ENABLE_TRACING);
+
+       /*
+        * setup the prefix mappings and schema info
+        */
+       ret = dsdb_module_search_dn(module, tmp_ctx, &schema_res,
+                                   schema_dn, schema_attrs);
+       if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+               goto failed;
+       } else if (ret != LDB_SUCCESS) {
+               ldb_asprintf_errstring(ldb, 
+                                      "dsdb_schema: failed to search the schema head: %s",
+                                      ldb_errstring(ldb));
+               goto failed;
+       }
+
+       /*
+        * load the attribute definitions
+        */
+       ret = dsdb_module_search(module, tmp_ctx, &a_res,
+                                schema_dn, LDB_SCOPE_ONELEVEL, NULL,
+                                "(objectClass=attributeSchema)");
+       if (ret != LDB_SUCCESS) {
+               ldb_asprintf_errstring(ldb, 
+                                      "dsdb_schema: failed to search attributeSchema objects: %s",
+                                      ldb_errstring(ldb));
+               goto failed;
+       }
+
+       /*
+        * load the objectClass definitions
+        */
+       ret = dsdb_module_search(module, tmp_ctx, &c_res,
+                                schema_dn, LDB_SCOPE_ONELEVEL, NULL,
+                                "(objectClass=classSchema)");
+       if (ret != LDB_SUCCESS) {
+               ldb_asprintf_errstring(ldb, 
+                                      "dsdb_schema: failed to search attributeSchema objects: %s",
+                                      ldb_errstring(ldb));
+               goto failed;
+       }
+
+       ret = dsdb_schema_from_ldb_results(tmp_ctx, ldb,
+                                          lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
+                                          schema_res, a_res, c_res, schema, &error_string);
+       if (ret != LDB_SUCCESS) {
+               ldb_asprintf_errstring(ldb, 
+                                                   "dsdb_schema load failed: %s",
+                                                   error_string);
+               goto failed;
+       }
+       talloc_steal(mem_ctx, *schema);
+
+failed:
+       if (flags & LDB_FLG_ENABLE_TRACING) {
+               flags = ldb_get_flags(ldb);
+               ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
+       }
+       talloc_free(tmp_ctx);
+       return ret;
+}      
+
+
 static int schema_fsmo_init(struct ldb_module *module)
 {
        struct ldb_context *ldb;
        TALLOC_CTX *mem_ctx;
        struct ldb_dn *schema_dn;
        struct dsdb_schema *schema;
-       char *error_string = NULL;
        int ret;
        struct schema_fsmo_private_data *data;
 
@@ -134,9 +230,9 @@ static int schema_fsmo_init(struct ldb_module *module)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ret = dsdb_schema_from_schema_dn(mem_ctx, ldb,
+       ret = dsdb_schema_from_schema_dn(mem_ctx, module,
                                         lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
-                                        schema_dn, &schema, &error_string);
+                                        schema_dn, &schema);
 
        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                ldb_reset_err_string(ldb);
@@ -147,9 +243,6 @@ static int schema_fsmo_init(struct ldb_module *module)
        }
 
        if (ret != LDB_SUCCESS) {
-               ldb_asprintf_errstring(ldb, 
-                                      "schema_fsmo_init: dsdb_schema load failed: %s",
-                                      error_string);
                talloc_free(mem_ctx);
                return ret;
        }
@@ -246,7 +339,6 @@ static int schema_fsmo_extended(struct ldb_module *module, struct ldb_request *r
        struct ldb_context *ldb;
        struct ldb_dn *schema_dn;
        struct dsdb_schema *schema;
-       char *error_string = NULL;
        int ret;
        TALLOC_CTX *mem_ctx;
 
@@ -270,9 +362,9 @@ static int schema_fsmo_extended(struct ldb_module *module, struct ldb_request *r
                return LDB_ERR_OPERATIONS_ERROR;
        }
        
-       ret = dsdb_schema_from_schema_dn(mem_ctx, ldb,
+       ret = dsdb_schema_from_schema_dn(mem_ctx, module,
                                         lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
-                                        schema_dn, &schema, &error_string);
+                                        schema_dn, &schema);
 
        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                ldb_reset_err_string(ldb);
@@ -283,9 +375,6 @@ static int schema_fsmo_extended(struct ldb_module *module, struct ldb_request *r
        }
 
        if (ret != LDB_SUCCESS) {
-               ldb_asprintf_errstring(ldb, 
-                                      "schema_fsmo_extended: dsdb_schema load failed: %s",
-                                      error_string);
                talloc_free(mem_ctx);
                return ldb_next_request(module, req);
        }

diff --git a/source4/dsdb/samdb/ldb_modules/subtree_delete.c b/source4/dsdb/samdb/ldb_modules/subtree_delete.c
index 241cc5f7d6fe85f7f450c09a95d45ae49035ae8d..e1ce9c1fa846a37cf1a92145a1c8baa8fab17dd0 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/subtree_delete.c
+++ b/source4/dsdb/samdb/ldb_modules/subtree_delete.c
@@ -55,6 +55,8 @@ static struct subtree_delete_context *subdel_ctx_init(struct ldb_module *module,
        ac->module = module;
        ac->req = req;
 
+       ac->num_children = 0;
+
        return ac;
 }
 

diff --git a/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py b/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py
index fe96b8822133ea7a8b1bf6f22cf5bbdaa0ba4552..c61d3973a1fd598216d68c4f024c25c96d518c9e 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py
+++ b/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py
@@ -311,6 +311,14 @@ class MapTestCase(MapBaseTestCase):
             "sambaDomainName": "TESTS"
             })
 
+        # Add a set of split records
+        self.ldb.add_ldif("""
+dn: """+ self.samba4.dn("cn=Domain Users") + """
+objectClass: group
+cn: Domain Users
+objectSid: S-1-5-21-4231626423-2410014848-2360679739-513
+""")
+
         # Add a set of split records
         self.ldb.add_ldif("""
 dn: """+ self.samba4.dn("cn=X") + """
@@ -459,7 +467,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         #   errors, letting the search fail with no results.
         #res = self.ldb.search("(objectSid=S-1-5-21-4231626423-2410014848-2360679739-552)", scope=SCOPE_DEFAULT, attrs)
         res = self.ldb.search(expression="(objectSid=*)", base=None, scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon", "objectSid"])
-        self.assertEquals(len(res), 3)
+        self.assertEquals(len(res), 4)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
         self.assertEquals(str(res[0]["dnsHostName"]), "x")
         self.assertEquals(str(res[0]["lastLogon"]), "x")
@@ -621,7 +629,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated local attribute
         res = self.ldb.search(expression="(!(revision=x))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
         self.assertTrue(not "dnsHostName" in res[0])
         self.assertEquals(str(res[0]["lastLogon"]), "y")
@@ -638,7 +646,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated remote attribute
         res = self.ldb.search(expression="(!(description=x))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 3)
+        self.assertEquals(len(res), 4)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Z"))
         self.assertEquals(str(res[0]["dnsHostName"]), "z")
         self.assertEquals(str(res[0]["lastLogon"]), "z")
@@ -649,7 +657,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated conjunction of local attributes
         res = self.ldb.search(expression="(!(&(codePage=x)(revision=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
         self.assertTrue(not "dnsHostName" in res[0])
         self.assertEquals(str(res[0]["lastLogon"]), "y")
@@ -666,7 +674,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated conjunction of remote attributes
         res = self.ldb.search(expression="(!(&(lastLogon=x)(description=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
         self.assertEquals(str(res[0]["dnsHostName"]), "y")
         self.assertEquals(str(res[0]["lastLogon"]), "y")
@@ -683,7 +691,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated conjunction of local and remote attribute
         res = self.ldb.search(expression="(!(&(codePage=x)(description=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
         self.assertTrue(not "dnsHostName" in res[0])
         self.assertEquals(str(res[0]["lastLogon"]), "y")
@@ -716,7 +724,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated disjunction of remote attributes
         res = self.ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 4)
+        self.assertEquals(len(res), 5)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
         self.assertEquals(str(res[0]["dnsHostName"]), "y")
         self.assertEquals(str(res[0]["lastLogon"]), "y")
@@ -730,7 +738,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
         # Search by negated disjunction of local and remote attribute
         res = self.ldb.search(expression="(!(|(revision=x)(lastLogon=y)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 4)
+        self.assertEquals(len(res), 5)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
         self.assertTrue(not "dnsHostName" in res[0])
         self.assertEquals(str(res[0]["lastLogon"]), "x")
@@ -743,7 +751,7 @@ objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
 
         # Search by complex parse tree
         res = self.ldb.search(expression="(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 6)
+        self.assertEquals(len(res), 7)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
         self.assertTrue(not "dnsHostName" in res[0])
         self.assertEquals(str(res[0]["lastLogon"]), "y")

diff --git a/source4/dsdb/samdb/ldb_modules/util.c b/source4/dsdb/samdb/ldb_modules/util.c
new file mode 100644 (file)
index 0000000..476eb08
--- /dev/null
+++ b/source4/dsdb/samdb/ldb_modules/util.c
@@ -0,0 +1,128 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+
+   Copyright (C) Andrew Tridgell 2009
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "ldb.h"
+#include "ldb_module.h"
+
+/*
+  search for attrs on one DN, in the modules below
+ */
+int dsdb_module_search_dn(struct ldb_module *module,
+                         TALLOC_CTX *mem_ctx,
+                         struct ldb_result **_res,
+                         struct ldb_dn *basedn,
+                         const char * const *attrs)
+{
+       int ret;
+       struct ldb_request *req;
+       TALLOC_CTX *tmp_ctx;
+       struct ldb_result *res;
+
+       tmp_ctx = talloc_new(mem_ctx);
+
+       res = talloc_zero(tmp_ctx, struct ldb_result);
+       if (!res) {
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
+       ret = ldb_build_search_req(&req, ldb_module_get_ctx(module), tmp_ctx,
+                                  basedn,
+                                  LDB_SCOPE_BASE,
+                                  NULL,
+                                  attrs,
+                                  NULL,
+                                  res,
+                                  ldb_search_default_callback,
+                                  NULL);
+       if (ret != LDB_SUCCESS) {
+               talloc_free(tmp_ctx);
+               return ret;
+       }
+
+       ret = ldb_next_request(module, req);
+       if (ret == LDB_SUCCESS) {
+               ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+       }
+
+       if (ret != LDB_SUCCESS) {
+               talloc_free(tmp_ctx);
+               return ret;
+       }
+
+       if (res->count != 1) {
+               /* we may be reading a DB that does not have the 'check base on search' option... */
+               ret = LDB_ERR_NO_SUCH_OBJECT;
+       } else {
+               *_res = talloc_steal(mem_ctx, res);
+       }
+       talloc_free(tmp_ctx);
+       return ret;
+}
+
+/*
+  search for attrs in the modules below
+ */
+int dsdb_module_search(struct ldb_module *module,
+                      TALLOC_CTX *mem_ctx,
+                      struct ldb_result **_res,
+                      struct ldb_dn *basedn, enum ldb_scope scope, 
+                      const char * const *attrs,
+                      const char *expression)
+{
+       int ret;
+       struct ldb_request *req;
+       TALLOC_CTX *tmp_ctx;
+       struct ldb_result *res;
+
+       tmp_ctx = talloc_new(mem_ctx);
+
+       res = talloc_zero(tmp_ctx, struct ldb_result);
+       if (!res) {
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
+       ret = ldb_build_search_req(&req, ldb_module_get_ctx(module), tmp_ctx,
+                                  basedn,
+                                  scope,
+                                  expression,
+                                  attrs,
+                                  NULL,
+                                  res,
+                                  ldb_search_default_callback,
+                                  NULL);
+       if (ret != LDB_SUCCESS) {
+               talloc_free(tmp_ctx);
+               return ret;
+       }
+
+       ret = ldb_next_request(module, req);
+       if (ret == LDB_SUCCESS) {
+               ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+       }
+
+       talloc_free(req);
+       if (ret == LDB_SUCCESS) {
+               *_res = talloc_steal(mem_ctx, res);
+       }
+       talloc_free(tmp_ctx);
+       return ret;
+}
+

diff --git a/source4/dsdb/samdb/ldb_modules/util.h b/source4/dsdb/samdb/ldb_modules/util.h
new file mode 100644 (file)
index 0000000..0a1ab83
--- /dev/null
+++ b/source4/dsdb/samdb/ldb_modules/util.h
@@ -0,0 +1,22 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+
+   Copyright (C) Andrew Tridgell 2009
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "dsdb/samdb/ldb_modules/util_proto.h"

diff --git a/source4/dsdb/samdb/samdb_privilege.c b/source4/dsdb/samdb/samdb_privilege.c
index e9c6f4c5271391e534fcf215a3bd40b19a2ddbd2..e7742c681cf6fab7338f133662ac64d9156c4f44 100644 (file)
--- a/source4/dsdb/samdb/samdb_privilege.c
+++ b/source4/dsdb/samdb/samdb_privilege.c
@@ -26,11 +26,30 @@
 #include "libcli/security/security.h"
 #include "../lib/util/util_ldb.h"
 #include "param/param.h"
+#include "ldb_wrap.h"
+
+/* connect to the privilege database */
+struct ldb_context *privilege_connect(TALLOC_CTX *mem_ctx, 
+                                     struct tevent_context *ev_ctx,
+                                     struct loadparm_context *lp_ctx)
+{
+       char *path;
+       struct ldb_context *pdb;
+
+       path = private_path(mem_ctx, lp_ctx, "privilege.ldb");
+       if (!path) return NULL;
+
+       pdb = ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, path, 
+                              NULL, NULL, 0, NULL);
+       talloc_free(path);
+
+       return pdb;
+}
 
 /*
   add privilege bits for one sid to a security_token
 */
-static NTSTATUS samdb_privilege_setup_sid(void *samctx, TALLOC_CTX *mem_ctx,
+static NTSTATUS samdb_privilege_setup_sid(struct ldb_context *pdb, TALLOC_CTX *mem_ctx,
                                          struct security_token *token,
                                          const struct dom_sid *sid)
 {
@@ -43,7 +62,7 @@ static NTSTATUS samdb_privilege_setup_sid(void *samctx, TALLOC_CTX *mem_ctx,
        sidstr = ldap_encode_ndr_dom_sid(mem_ctx, sid);
        NT_STATUS_HAVE_NO_MEMORY(sidstr);
 
-       ret = gendb_search(samctx, mem_ctx, NULL, &res, attrs, "objectSid=%s", sidstr);
+       ret = gendb_search(pdb, mem_ctx, NULL, &res, attrs, "objectSid=%s", sidstr);
        talloc_free(sidstr);
        if (ret != 1) {
                /* not an error to not match */
@@ -76,7 +95,7 @@ static NTSTATUS samdb_privilege_setup_sid(void *samctx, TALLOC_CTX *mem_ctx,
 NTSTATUS samdb_privilege_setup(struct tevent_context *ev_ctx, 
                               struct loadparm_context *lp_ctx, struct security_token *token)
 {
-       void *samctx;
+       struct ldb_context *pdb;
        TALLOC_CTX *mem_ctx;
        int i;
        NTSTATUS status;
@@ -98,8 +117,8 @@ NTSTATUS samdb_privilege_setup(struct tevent_context *ev_ctx,
        }
 
        mem_ctx = talloc_new(token);
-       samctx = samdb_connect(mem_ctx, ev_ctx, lp_ctx, system_session(mem_ctx, lp_ctx));
-       if (samctx == NULL) {
+       pdb = privilege_connect(mem_ctx, ev_ctx, lp_ctx);
+       if (pdb == NULL) {
                talloc_free(mem_ctx);
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
@@ -107,7 +126,7 @@ NTSTATUS samdb_privilege_setup(struct tevent_context *ev_ctx,
        token->privilege_mask = 0;
        
        for (i=0;i<token->num_sids;i++) {
-               status = samdb_privilege_setup_sid(samctx, mem_ctx,
+               status = samdb_privilege_setup_sid(pdb, mem_ctx,
                                                   token, token->sids[i]);
                if (!NT_STATUS_IS_OK(status)) {
                        talloc_free(mem_ctx);

diff --git a/source4/dsdb/schema/prefixmap.h b/source4/dsdb/schema/prefixmap.h
new file mode 100644 (file)
index 0000000..7b28c88
--- /dev/null
+++ b/source4/dsdb/schema/prefixmap.h
@@ -0,0 +1,45 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DRS::prefixMap data structures
+
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
+   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/>.
+*/
+
+#ifndef _DSDB_PREFIXMAP_H
+#define _DSDB_PREFIXMAP_H
+
+/**
+ * oid-prefix in prefixmap
+ */
+struct dsdb_schema_prefixmap_oid {
+       uint32_t id;
+       DATA_BLOB *bin_oid; /* partial binary-oid prefix */
+};
+
+/**
+ * DSDB prefixMap internal presentation
+ */
+struct dsdb_schema_prefixmap {
+       uint32_t length;
+       struct dsdb_schema_prefixmap_oid *prefixes;
+};
+
+
+#include "dsdb/schema/proto.h"
+
+
+#endif /* _DSDB_PREFIXMAP_H */

diff --git a/source4/dsdb/schema/schema.h b/source4/dsdb/schema/schema.h
index 4e7e503931978e4227b84afb27433b2370992f43..ddd9b375f6d686e8f0cea9813d4c439421478355 100644 (file)
--- a/source4/dsdb/schema/schema.h
+++ b/source4/dsdb/schema/schema.h
@@ -119,6 +119,7 @@ struct dsdb_class {
        const char **mustContain;
        const char **mayContain;
        const char **possibleInferiors;
+       const char **systemPossibleInferiors;
 
        const char *defaultSecurityDescriptor;
 

diff --git a/source4/dsdb/schema/schema_inferiors.c b/source4/dsdb/schema/schema_inferiors.c
index b02d557c5884708de50da52db7c64c1c0e714092..ecac74a9543576d641c2f4fb0222e7558a0ee3b7 100644 (file)
--- a/source4/dsdb/schema/schema_inferiors.c
+++ b/source4/dsdb/schema/schema_inferiors.c
@@ -149,19 +149,22 @@ void schema_subclasses_order_recurse(struct dsdb_schema *schema, struct dsdb_cla
        return;
 }
 
-static void schema_create_subclasses(struct dsdb_schema *schema)
+static int schema_create_subclasses(struct dsdb_schema *schema)
 {
-       struct dsdb_class *schema_class;
+       struct dsdb_class *schema_class, *top;
 
        for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
                struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, schema_class->subClassOf);
                if (schema_class2 == NULL) {
                        DEBUG(0,("ERROR: no subClassOf for '%s'\n", schema_class->lDAPDisplayName));
-                       continue;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
                if (schema_class2 && schema_class != schema_class2) {
                        if (schema_class2->subclasses_direct == NULL) {
                                schema_class2->subclasses_direct = str_list_make_empty(schema_class2);
+                               if (!schema_class2->subclasses_direct) {
+                                       return LDB_ERR_OPERATIONS_ERROR;
+                               }
                        }
                        schema_class2->subclasses_direct = str_list_add_const(schema_class2->subclasses_direct, 
                                                                        schema_class->lDAPDisplayName);
@@ -175,7 +178,14 @@ static void schema_create_subclasses(struct dsdb_schema *schema)
                schema_class->subClass_order = 0;
        }
 
-       schema_subclasses_order_recurse(schema, dsdb_class_by_lDAPDisplayName(schema, "top"), 1);
+       top = dsdb_class_by_lDAPDisplayName(schema, "top");
+       if (!top) {
+               DEBUG(0,("ERROR: no 'top' class in loaded schema\n"));
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
+       schema_subclasses_order_recurse(schema, top, 1);
+       return LDB_SUCCESS;
 }
 
 static void schema_fill_possible_inferiors(struct dsdb_schema *schema, struct dsdb_class *schema_class)
@@ -198,6 +208,25 @@ static void schema_fill_possible_inferiors(struct dsdb_schema *schema, struct ds
        schema_class->possibleInferiors = str_list_unique(schema_class->possibleInferiors);
 }
 
+static void schema_fill_system_possible_inferiors(struct dsdb_schema *schema, struct dsdb_class *schema_class)
+{
+       struct dsdb_class *c2;
+
+       for (c2=schema->classes; c2; c2=c2->next) {
+               char **superiors = schema_posssuperiors(schema, c2);
+               if (c2->objectClassCategory != 2
+                   && c2->objectClassCategory != 3
+                   && str_list_check(superiors, schema_class->lDAPDisplayName)) {
+                       if (schema_class->systemPossibleInferiors == NULL) {
+                               schema_class->systemPossibleInferiors = str_list_make_empty(schema_class);
+                       }
+                       schema_class->systemPossibleInferiors = str_list_add_const(schema_class->systemPossibleInferiors,
+                                                                                  c2->lDAPDisplayName);
+               }
+       }
+       schema_class->systemPossibleInferiors = str_list_unique(schema_class->systemPossibleInferiors);
+}
+
 /*
   fill in a string class name from a governs_ID
  */
@@ -275,16 +304,21 @@ static void schema_fill_from_ids(struct dsdb_schema *schema)
        }
 }
 
-void schema_fill_constructed(struct dsdb_schema *schema) 
+int schema_fill_constructed(struct dsdb_schema *schema) 
 {
+       int ret;
        struct dsdb_class *schema_class;
 
        schema_fill_from_ids(schema);
 
-       schema_create_subclasses(schema);
+       ret = schema_create_subclasses(schema);
+       if (ret != LDB_SUCCESS) {
+               return ret;
+       }
 
        for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
                schema_fill_possible_inferiors(schema, schema_class);
+               schema_fill_system_possible_inferiors(schema, schema_class);
        }
 
        /* free up our internal cache elements */
@@ -298,4 +332,5 @@ void schema_fill_constructed(struct dsdb_schema *schema)
                schema_class->subclasses = NULL;
                schema_class->posssuperiors = NULL;
        }
+       return LDB_SUCCESS;
 }

diff --git a/source4/dsdb/schema/schema_init.c b/source4/dsdb/schema/schema_init.c
index b876ab09fc9c29683c8929d97361e1d9f2d29776..f8b7d5dd4431cea5cc5902905c86de72f0dbe025 100644 (file)
--- a/source4/dsdb/schema/schema_init.c
+++ b/source4/dsdb/schema/schema_init.c
@@ -29,6 +29,9 @@
 #include "librpc/gen_ndr/ndr_drsblobs.h"
 #include "param/param.h"
 #include "lib/ldb/include/ldb_module.h"
+#include "../lib/util/asn1.h"
+
+static WERROR dsdb_read_prefixes_from_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, uint32_t* num_prefixes, struct dsdb_schema_oid_prefix **prefixes);
 
 struct dsdb_schema *dsdb_new_schema(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
 {
@@ -50,11 +53,11 @@ WERROR dsdb_load_oid_mappings_drsuapi(struct dsdb_schema *schema, const struct d
        W_ERROR_HAVE_NO_MEMORY(schema->prefixes);
 
        for (i=0, j=0; i < ctr->num_mappings; i++) {
-               if (ctr->mappings[i].oid.oid == NULL) {
+               if (ctr->mappings[i].oid.binary_oid == NULL) {
                        return WERR_INVALID_PARAM;
                }
 
-               if (strncasecmp(ctr->mappings[i].oid.oid, "ff", 2) == 0) {
+               if (ctr->mappings[i].oid.binary_oid[0] == 0xFF) {
                        if (ctr->mappings[i].id_prefix != 0) {
                                return WERR_INVALID_PARAM;
                        }
@@ -64,21 +67,33 @@ WERROR dsdb_load_oid_mappings_drsuapi(struct dsdb_schema *schema, const struct d
                                return WERR_INVALID_PARAM;
                        }
 
-                       if (ctr->mappings[i].oid.__ndr_size != 21) {
+                       if (ctr->mappings[i].oid.length != 21) {
                                return WERR_INVALID_PARAM;
                        }
 
-                       schema->schema_info = talloc_strdup(schema, ctr->mappings[i].oid.oid);
+                       schema->schema_info = hex_encode_talloc(schema,
+                                                               ctr->mappings[i].oid.binary_oid,
+                                                               ctr->mappings[i].oid.length);
                        W_ERROR_HAVE_NO_MEMORY(schema->schema_info);
                } else {
+                       DATA_BLOB oid_blob;
+                       const char *partial_oid = NULL;
+
                        /* the last array member should contain the magic value not a oid */
                        if (i == (ctr->num_mappings - 1)) {
                                return WERR_INVALID_PARAM;
                        }
 
+                       oid_blob = data_blob_const(ctr->mappings[i].oid.binary_oid,
+                                                  ctr->mappings[i].oid.length);
+                       if (!ber_read_partial_OID_String(schema->prefixes, oid_blob, &partial_oid)) {
+                               DEBUG(0, ("ber_read_partial_OID failed on prefixMap item with id: 0x%X",
+                                         ctr->mappings[i].id_prefix));
+                               return WERR_INVALID_PARAM;
+                       }
+
                        schema->prefixes[j].id  = ctr->mappings[i].id_prefix<<16;
-                       schema->prefixes[j].oid = talloc_asprintf(schema->prefixes, "%s.",
-                                                                 ctr->mappings[i].oid.oid);
+                       schema->prefixes[j].oid = partial_oid;
                        W_ERROR_HAVE_NO_MEMORY(schema->prefixes[j].oid);
                        schema->prefixes[j].oid_len = strlen(schema->prefixes[j].oid);
                        j++;
@@ -96,7 +111,7 @@ WERROR dsdb_load_oid_mappings_ldb(struct dsdb_schema *schema,
        WERROR status;
        enum ndr_err_code ndr_err;
        struct prefixMapBlob pfm;
-       char *schema_info;
+       DATA_BLOB schema_info_blob;
 
        TALLOC_CTX *mem_ctx = talloc_new(schema);
        W_ERROR_HAVE_NO_MEMORY(mem_ctx);
@@ -125,12 +140,12 @@ WERROR dsdb_load_oid_mappings_ldb(struct dsdb_schema *schema,
                                               pfm.ctr.dsdb.num_mappings);
        W_ERROR_HAVE_NO_MEMORY(pfm.ctr.dsdb.mappings);
 
-       schema_info = data_blob_hex_string(pfm.ctr.dsdb.mappings, schemaInfo);
-       W_ERROR_HAVE_NO_MEMORY(schema_info);
+       schema_info_blob = data_blob_dup_talloc(pfm.ctr.dsdb.mappings, schemaInfo);
+       W_ERROR_HAVE_NO_MEMORY(schema_info_blob.data);
 
        pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].id_prefix          = 0;    
-       pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.__ndr_size     = schemaInfo->length;
-       pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.oid            = schema_info;
+       pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.length         = schemaInfo->length;
+       pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.binary_oid     = schema_info_blob.data;
 
        /* call the drsuapi version */
        status = dsdb_load_oid_mappings_drsuapi(schema, &pfm.ctr.dsdb);
@@ -146,6 +161,7 @@ WERROR dsdb_get_oid_mappings_drsuapi(const struct dsdb_schema *schema,
                                     TALLOC_CTX *mem_ctx,
                                     struct drsuapi_DsReplicaOIDMapping_Ctr **_ctr)
 {
+       DATA_BLOB oid_blob;
        struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
        uint32_t i;
 
@@ -158,18 +174,23 @@ WERROR dsdb_get_oid_mappings_drsuapi(const struct dsdb_schema *schema,
        W_ERROR_HAVE_NO_MEMORY(ctr->mappings);
 
        for (i=0; i < schema->num_prefixes; i++) {
+               if (!ber_write_partial_OID_String(ctr->mappings, &oid_blob, schema->prefixes[i].oid)) {
+                       DEBUG(0, ("write_partial_OID failed for %s", schema->prefixes[i].oid));
+                       return WERR_INTERNAL_ERROR;
+               }
+
                ctr->mappings[i].id_prefix      = schema->prefixes[i].id>>16;
-               ctr->mappings[i].oid.oid        = talloc_strndup(ctr->mappings,
-                                                                schema->prefixes[i].oid,
-                                                                schema->prefixes[i].oid_len - 1);
-               W_ERROR_HAVE_NO_MEMORY(ctr->mappings[i].oid.oid);
+               ctr->mappings[i].oid.length     = oid_blob.length;
+               ctr->mappings[i].oid.binary_oid = oid_blob.data;
        }
 
        if (include_schema_info) {
+               oid_blob = strhex_to_data_blob(ctr->mappings, schema->schema_info);
+               W_ERROR_HAVE_NO_MEMORY(oid_blob.data);
+
                ctr->mappings[i].id_prefix      = 0;
-               ctr->mappings[i].oid.oid        = talloc_strdup(ctr->mappings,
-                                                               schema->schema_info);
-               W_ERROR_HAVE_NO_MEMORY(ctr->mappings[i].oid.oid);
+               ctr->mappings[i].oid.length     = oid_blob.length;
+               ctr->mappings[i].oid.binary_oid = oid_blob.data;
        }
 
        *_ctr = ctr;
@@ -209,13 +230,14 @@ WERROR dsdb_get_oid_mappings_ldb(const struct dsdb_schema *schema,
 WERROR dsdb_verify_oid_mappings_drsuapi(const struct dsdb_schema *schema, const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr)
 {
        uint32_t i,j;
+       DATA_BLOB oid_blob;
 
        for (i=0; i < ctr->num_mappings; i++) {
-               if (ctr->mappings[i].oid.oid == NULL) {
+               if (ctr->mappings[i].oid.binary_oid == NULL) {
                        return WERR_INVALID_PARAM;
                }
 
-               if (strncasecmp(ctr->mappings[i].oid.oid, "ff", 2) == 0) {
+               if (ctr->mappings[i].oid.binary_oid[0] == 0xFF) {
                        if (ctr->mappings[i].id_prefix != 0) {
                                return WERR_INVALID_PARAM;
                        }
@@ -225,13 +247,19 @@ WERROR dsdb_verify_oid_mappings_drsuapi(const struct dsdb_schema *schema, const
                                return WERR_INVALID_PARAM;
                        }
 
-                       if (ctr->mappings[i].oid.__ndr_size != 21) {
+                       if (ctr->mappings[i].oid.length != 21) {
                                return WERR_INVALID_PARAM;
                        }
 
-                       if (strcasecmp(schema->schema_info, ctr->mappings[i].oid.oid) != 0) {
+                       oid_blob = strhex_to_data_blob(NULL, schema->schema_info);
+                       W_ERROR_HAVE_NO_MEMORY(oid_blob.data);
+
+                       if (memcmp(oid_blob.data, ctr->mappings[i].oid.binary_oid, 21) != 0) {
+                               data_blob_free(&oid_blob);
                                return WERR_DS_DRA_SCHEMA_MISMATCH;
                        }
+
+                       data_blob_free(&oid_blob);
                } else {
                        /* the last array member should contain the magic value not a oid */
                        if (i == (ctr->num_mappings - 1)) {
@@ -239,21 +267,26 @@ WERROR dsdb_verify_oid_mappings_drsuapi(const struct dsdb_schema *schema, const
                        }
 
                        for (j=0; j < schema->num_prefixes; j++) {
-                               size_t oid_len;
                                if (schema->prefixes[j].id != (ctr->mappings[i].id_prefix<<16)) {
                                        continue;
                                }
 
-                               oid_len = strlen(ctr->mappings[i].oid.oid);
+                               if (!ber_write_partial_OID_String(NULL, &oid_blob, schema->prefixes[j].oid)) {
+                                       return WERR_INTERNAL_ERROR;
+                               }
 
-                               if (oid_len != (schema->prefixes[j].oid_len - 1)) {
+                               if (oid_blob.length != ctr->mappings[j].oid.length) {
+                                       data_blob_free(&oid_blob);
                                        return WERR_DS_DRA_SCHEMA_MISMATCH;
                                }
 
-                               if (strncmp(ctr->mappings[i].oid.oid, schema->prefixes[j].oid, oid_len) != 0) {
-                                       return WERR_DS_DRA_SCHEMA_MISMATCH;                             
+                               if (memcmp(ctr->mappings[i].oid.binary_oid, oid_blob.data, oid_blob.length) != 0) {
+                                       data_blob_free(&oid_blob);
+                                       return WERR_DS_DRA_SCHEMA_MISMATCH;
                                }
 
+                               data_blob_free(&oid_blob);
+
                                break;
                        }
 
@@ -282,7 +315,7 @@ WERROR dsdb_map_int2oid(const struct dsdb_schema *schema, uint32_t in, TALLOC_CT
                        continue;
                }
 
-               val = talloc_asprintf(mem_ctx, "%s%u",
+               val = talloc_asprintf(mem_ctx, "%s.%u",
                                      schema->prefixes[i].oid,
                                      in & 0xFFFF);
                W_ERROR_HAVE_NO_MEMORY(val);
@@ -389,8 +422,6 @@ WERROR dsdb_prefix_map_update(TALLOC_CTX *mem_ctx, uint32_t *num_prefixes, struc
                DEBUG(0,("dsdb_prefix_map_update: size of the remaining string invalid\n"));
                return WERR_FOOBAR;
        }
-       /* Add one because we need to copy the dot */
-       size += 1;
 
        /* Create a spot in the prefixMap for one more prefix*/
        (*prefixes) = talloc_realloc(mem_ctx, *prefixes, struct dsdb_schema_oid_prefix, new_num_prefixes);
@@ -410,37 +441,33 @@ WERROR dsdb_prefix_map_update(TALLOC_CTX *mem_ctx, uint32_t *num_prefixes, struc
 WERROR dsdb_find_prefix_for_oid(uint32_t num_prefixes, const struct dsdb_schema_oid_prefix *prefixes, const char *in, uint32_t *out)
 {
        uint32_t i;
+       char *oid_prefix;
+       char *pstr;
+       char *end_str;
+       unsigned val;
 
-       for (i=0; i < num_prefixes; i++) {
-               const char *val_str;
-               char *end_str;
-               unsigned val;
+       /* make oid prefix, i.e. oid w/o last subidentifier */
+       pstr = strrchr(in, '.');
+       if (!pstr)      return WERR_INVALID_PARAM;
+       if (pstr < in)  return WERR_INVALID_PARAM;
+       if ((pstr - in) < 4) return WERR_INVALID_PARAM;
 
-               if (strncmp(prefixes[i].oid, in, prefixes[i].oid_len) != 0) {
-                       continue;
-               }
+       oid_prefix = talloc_strndup(0, in, pstr - in);
 
-               val_str = in + prefixes[i].oid_len;
-               end_str = NULL;
-               errno = 0;
-
-               if (val_str[0] == '\0') {
-                       return WERR_INVALID_PARAM;
+       for (i=0; i < num_prefixes; i++) {
+               if (strcmp(prefixes[i].oid, oid_prefix) == 0) {
+                       break;
                }
+       }
 
-               /* two '.' chars are invalid */
-               if (val_str[0] == '.') {
-                       return WERR_INVALID_PARAM;
-               }
+       talloc_free(oid_prefix);
 
-               val = strtoul(val_str, &end_str, 10);
-               if (end_str[0] == '.' && end_str[1] != '\0') {
-                       /*
-                        * if it's a '.' and not the last char
-                        * then maybe an other mapping apply
-                        */
-                       continue;
-               } else if (end_str[0] != '\0') {
+       if (i < num_prefixes) {
+               /* move next to '.' char */
+               pstr++;
+
+               val = strtoul(pstr, &end_str, 10);
+               if (end_str[0] != '\0') {
                        return WERR_INVALID_PARAM;
                } else if (val > 0xFFFF) {
                        return WERR_INVALID_PARAM;
@@ -487,8 +514,16 @@ WERROR dsdb_write_prefixes_from_schema_to_ldb(TALLOC_CTX *mem_ctx, struct ldb_co
        }
 
        for (i=0; i < schema->num_prefixes; i++) {
-               pm.ctr.dsdb.mappings[i].id_prefix = schema->prefixes[i].id>>16;
-               pm.ctr.dsdb.mappings[i].oid.oid = talloc_strdup(pm.ctr.dsdb.mappings, schema->prefixes[i].oid);
+               DATA_BLOB oid_blob;
+
+               if (!ber_write_partial_OID_String(pm.ctr.dsdb.mappings, &oid_blob, schema->prefixes[i].oid)) {
+                       DEBUG(0, ("write_partial_OID failed for %s", schema->prefixes[i].oid));
+                       return WERR_INTERNAL_ERROR;
+               }
+
+               pm.ctr.dsdb.mappings[i].id_prefix       = schema->prefixes[i].id>>16;
+               pm.ctr.dsdb.mappings[i].oid.length      = oid_blob.length;
+               pm.ctr.dsdb.mappings[i].oid.binary_oid  = oid_blob.data;
        }
 
        ndr_err = ndr_push_struct_blob(&ndr_blob, msg,
@@ -519,14 +554,14 @@ WERROR dsdb_write_prefixes_from_schema_to_ldb(TALLOC_CTX *mem_ctx, struct ldb_co
        return WERR_OK;
 }
 
-WERROR dsdb_read_prefixes_from_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, uint32_t* num_prefixes, struct dsdb_schema_oid_prefix **prefixes)
+static WERROR dsdb_read_prefixes_from_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, uint32_t* num_prefixes, struct dsdb_schema_oid_prefix **prefixes)
 {
        struct prefixMapBlob *blob;
        enum ndr_err_code ndr_err;
        uint32_t i;
        const struct ldb_val *prefix_val;
        struct ldb_dn *schema_dn;
-       struct ldb_result *schema_res;
+       struct ldb_result *schema_res = NULL;
        int ret;    
        static const char *schema_attrs[] = {
                "prefixMap",
@@ -586,10 +621,21 @@ WERROR dsdb_read_prefixes_from_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
                return WERR_NOMEM;
        }
        for (i=0; i < blob->ctr.dsdb.num_mappings; i++) {
-               char *oid;
+               DATA_BLOB oid_blob;
+               const char *partial_oid;
+
+               oid_blob = data_blob_const(blob->ctr.dsdb.mappings[i].oid.binary_oid,
+                                          blob->ctr.dsdb.mappings[i].oid.length);
+
+               if (!ber_read_partial_OID_String(mem_ctx, oid_blob, &partial_oid)) {
+                       DEBUG(0, ("ber_read_partial_OID failed on prefixMap item with id: 0x%X",
+                                       blob->ctr.dsdb.mappings[i].id_prefix));
+                       talloc_free(blob);
+                       return WERR_INVALID_PARAM;
+               }
+
                (*prefixes)[i].id = blob->ctr.dsdb.mappings[i].id_prefix<<16;
-               oid = talloc_strdup(mem_ctx, blob->ctr.dsdb.mappings[i].oid.oid);
-               (*prefixes)[i].oid = talloc_asprintf_append(oid, "."); 
+               (*prefixes)[i].oid = partial_oid;
                (*prefixes)[i].oid_len = strlen((*prefixes)[i].oid);
        }
 
@@ -906,7 +952,7 @@ WERROR dsdb_class_from_ldb(const struct dsdb_schema *schema,
 /* 
  Create a DSDB schema from the ldb results provided.  This is called
  directly when the schema is provisioned from an on-disk LDIF file, or
- from dsdb_schema_from_schema_dn below
+ from dsdb_schema_from_schema_dn in schema_fsmo
 */
 
 int dsdb_schema_from_ldb_results(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
@@ -1013,115 +1059,6 @@ int dsdb_schema_from_ldb_results(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
        return LDB_SUCCESS;
 }
 
-/*
-  Given an LDB, and the DN, return a populated schema
-*/
-
-int dsdb_schema_from_schema_dn(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
-                              struct smb_iconv_convenience *iconv_convenience, 
-                              struct ldb_dn *schema_dn,
-                              struct dsdb_schema **schema,
-                              char **error_string_out) 
-{
-       TALLOC_CTX *tmp_ctx;
-       char *error_string;
-       int ret;
-
-       struct ldb_result *schema_res;
-       struct ldb_result *a_res;
-       struct ldb_result *c_res;
-       static const char *schema_attrs[] = {
-               "prefixMap",
-               "schemaInfo",
-               "fSMORoleOwner",
-               NULL
-       };
-       unsigned flags;
-
-       tmp_ctx = talloc_new(mem_ctx);
-       if (!tmp_ctx) {
-               dsdb_oom(error_string_out, mem_ctx);
-               return LDB_ERR_OPERATIONS_ERROR;
-       }
-
-       /* we don't want to trace the schema load */
-       flags = ldb_get_flags(ldb);
-       ldb_set_flags(ldb, flags & ~LDB_FLG_ENABLE_TRACING);
-
-       /*
-        * setup the prefix mappings and schema info
-        */
-       ret = ldb_search(ldb, tmp_ctx, &schema_res,
-                        schema_dn, LDB_SCOPE_BASE, schema_attrs, NULL);
-       if (ret == LDB_ERR_NO_SUCH_OBJECT) {
-               goto failed;
-       } else if (ret != LDB_SUCCESS) {
-               *error_string_out = talloc_asprintf(mem_ctx, 
-                                      "dsdb_schema: failed to search the schema head: %s",
-                                      ldb_errstring(ldb));
-               goto failed;
-       }
-       if (schema_res->count != 1) {
-               *error_string_out = talloc_asprintf(mem_ctx, 
-                             "dsdb_schema: [%u] schema heads found on a base search",
-                             schema_res->count);
-               goto failed;
-       }
-
-       /*
-        * load the attribute definitions
-        */
-       ret = ldb_search(ldb, tmp_ctx, &a_res,
-                        schema_dn, LDB_SCOPE_ONELEVEL, NULL,
-                        "(objectClass=attributeSchema)");
-       if (ret != LDB_SUCCESS) {
-               *error_string_out = talloc_asprintf(mem_ctx, 
-                                      "dsdb_schema: failed to search attributeSchema objects: %s",
-                                      ldb_errstring(ldb));
-               goto failed;
-       }
-
-       /*
-        * load the objectClass definitions
-        */
-       ret = ldb_search(ldb, tmp_ctx, &c_res,
-                        schema_dn, LDB_SCOPE_ONELEVEL, NULL,
-                        "(objectClass=classSchema)");
-       if (ret != LDB_SUCCESS) {
-               *error_string_out = talloc_asprintf(mem_ctx, 
-                                      "dsdb_schema: failed to search attributeSchema objects: %s",
-                                      ldb_errstring(ldb));
-               goto failed;
-       }
-
-       ret = dsdb_schema_from_ldb_results(tmp_ctx, ldb,
-                                          lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
-                                          schema_res, a_res, c_res, schema, &error_string);
-       if (ret != LDB_SUCCESS) {
-               *error_string_out = talloc_asprintf(mem_ctx, 
-                                                   "dsdb_schema load failed: %s",
-                                                   error_string);
-               goto failed;
-       }
-       talloc_steal(mem_ctx, *schema);
-       talloc_free(tmp_ctx);
-
-       if (flags & LDB_FLG_ENABLE_TRACING) {
-               flags = ldb_get_flags(ldb);
-               ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
-       }
-
-       return LDB_SUCCESS;
-
-failed:
-       if (flags & LDB_FLG_ENABLE_TRACING) {
-               flags = ldb_get_flags(ldb);
-               ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
-       }
-       talloc_free(tmp_ctx);
-       return ret;
-}      
-
 
 static const struct {
        const char *name;

diff --git a/source4/dsdb/schema/schema_prefixmap.c b/source4/dsdb/schema/schema_prefixmap.c
new file mode 100644 (file)
index 0000000..d24c5ad
--- /dev/null
+++ b/source4/dsdb/schema/schema_prefixmap.c
@@ -0,0 +1,22 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DRS::prefixMap implementation
+
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"

diff --git a/source4/dsdb/schema/schema_set.c b/source4/dsdb/schema/schema_set.c
index 6f09f635960e1cfddd709d285bdcf44304ec7fcb..9f22b3233407a4b37651ee95e737ac5d97994709 100644 (file)
--- a/source4/dsdb/schema/schema_set.c
+++ b/source4/dsdb/schema/schema_set.c
@@ -346,7 +346,10 @@ int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
                return ret;
        }
 
-       schema_fill_constructed(schema);
+       ret = schema_fill_constructed(schema);
+       if (ret != LDB_SUCCESS) {
+               return ret;
+       }
 
        ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
        if (ret != LDB_SUCCESS) {

diff --git a/source4/dsdb/schema/schema_syntax.c b/source4/dsdb/schema/schema_syntax.c
index c564471d4bcfd25ccdd5815c0c408c0f53f0879b..cbbd4a863646c5b7c845868c41bf6bdd4f65c404 100644 (file)
--- a/source4/dsdb/schema/schema_syntax.c
+++ b/source4/dsdb/schema/schema_syntax.c
@@ -1204,6 +1204,8 @@ static WERROR dsdb_syntax_DN_ldb_to_drsuapi(struct ldb_context *ldb,
        return WERR_OK;
 }
 
+
+
 static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb, 
                                                   const struct dsdb_schema *schema,
                                                   const struct dsdb_attribute *attr,
@@ -1212,6 +1214,7 @@ static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb,
                                                   struct ldb_message_element *out)
 {
        uint32_t i;
+       int ret;
 
        out->flags      = 0;
        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
@@ -1222,39 +1225,81 @@ static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb,
        W_ERROR_HAVE_NO_MEMORY(out->values);
 
        for (i=0; i < out->num_values; i++) {
-               struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
-               char *binary;
-               char *str;
+               struct drsuapi_DsReplicaObjectIdentifier3Binary id3;
                enum ndr_err_code ndr_err;
+               DATA_BLOB guid_blob;
+               struct ldb_dn *dn;
+               TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+               if (!tmp_ctx) {
+                       W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+               }
 
                if (in->value_ctr.values[i].blob == NULL) {
+                       talloc_free(tmp_ctx);
                        return WERR_FOOBAR;
                }
 
                if (in->value_ctr.values[i].blob->length == 0) {
+                       talloc_free(tmp_ctx);
                        return WERR_FOOBAR;
                }
 
-               ndr_err = ndr_pull_struct_blob_all(in->value_ctr.values[i].blob,
-                                                  out->values, schema->iconv_convenience, &id3b,
-                                                  (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
+               
+               /* windows sometimes sends an extra two pad bytes here */
+               ndr_err = ndr_pull_struct_blob(in->value_ctr.values[i].blob,
+                                              tmp_ctx, schema->iconv_convenience, &id3,
+                                              (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                       talloc_free(tmp_ctx);
                        return ntstatus_to_werror(status);
                }
 
-               /* TODO: handle id3.guid and id3.sid */
-               binary = data_blob_hex_string(out->values, &id3b.binary);
-               W_ERROR_HAVE_NO_MEMORY(binary);
+               dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);
+               if (!dn) {
+                       talloc_free(tmp_ctx);
+                       /* If this fails, it must be out of memory, as it does not do much parsing */
+                       W_ERROR_HAVE_NO_MEMORY(dn);
+               }
 
-               str = talloc_asprintf(out->values, "B:%u:%s:%s",
-                                     (unsigned int)(id3b.binary.length * 2), /* because of 2 hex chars per byte */
-                                     binary,
-                                     id3b.dn);
-               W_ERROR_HAVE_NO_MEMORY(str);
+               ndr_err = ndr_push_struct_blob(&guid_blob, tmp_ctx, schema->iconv_convenience, &id3.guid,
+                                              (ndr_push_flags_fn_t)ndr_push_GUID);
+               if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                       NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                       talloc_free(tmp_ctx);
+                       return ntstatus_to_werror(status);
+               }
 
-               /* TODO: handle id3.guid and id3.sid */
-               out->values[i] = data_blob_string_const(str);
+               ret = ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
+               if (ret != LDB_SUCCESS) {
+                       talloc_free(tmp_ctx);
+                       return WERR_FOOBAR;
+               }
+
+               talloc_free(guid_blob.data);
+
+               if (id3.__ndr_size_sid) {
+                       DATA_BLOB sid_blob;
+                       ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience, &id3.sid,
+                                                      (ndr_push_flags_fn_t)ndr_push_dom_sid);
+                       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                               NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                               talloc_free(tmp_ctx);
+                               return ntstatus_to_werror(status);
+                       }
+
+                       ret = ldb_dn_set_extended_component(dn, "SID", &sid_blob);
+                       if (ret != LDB_SUCCESS) {
+                               talloc_free(tmp_ctx);
+                               return WERR_FOOBAR;
+                       }
+               }
+
+               /* set binary stuff */
+               ldb_dn_set_binary(dn, &id3.binary);
+
+               out->values[i] = data_blob_string_const(ldb_dn_get_extended_linearized(out->values, dn, 1));
+               talloc_free(tmp_ctx);
        }
 
        return WERR_OK;
@@ -1285,27 +1330,72 @@ static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(struct ldb_context *ldb,
        W_ERROR_HAVE_NO_MEMORY(blobs);
 
        for (i=0; i < in->num_values; i++) {
-               struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
+               struct drsuapi_DsReplicaObjectIdentifier3Binary id3;
                enum ndr_err_code ndr_err;
+               const DATA_BLOB *guid_blob, *sid_blob;
+               struct ldb_dn *dn;
+               TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+               W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
 
                out->value_ctr.values[i].blob   = &blobs[i];
 
-               /* TODO: handle id3b.guid and id3b.sid, id3.binary */
-               ZERO_STRUCT(id3b);
-               id3b.dn         = (const char *)in->values[i].data;
-               id3b.binary     = data_blob(NULL, 0);
+               dn = ldb_dn_from_ldb_val(tmp_ctx, ldb, &in->values[i]);
+
+               W_ERROR_HAVE_NO_MEMORY(dn);
+
+               guid_blob = ldb_dn_get_extended_component(dn, "GUID");
 
-               ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3b,
-                                              (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
+               ZERO_STRUCT(id3);
+
+               if (guid_blob) {
+                       ndr_err = ndr_pull_struct_blob_all(guid_blob, 
+                                                          tmp_ctx, schema->iconv_convenience, &id3.guid,
+                                                          (ndr_pull_flags_fn_t)ndr_pull_GUID);
+                       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                               NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                               talloc_free(tmp_ctx);
+                               return ntstatus_to_werror(status);
+                       }
+               }
+
+               sid_blob = ldb_dn_get_extended_component(dn, "SID");
+               if (sid_blob) {
+                       
+                       ndr_err = ndr_pull_struct_blob_all(sid_blob, 
+                                                          tmp_ctx, schema->iconv_convenience, &id3.sid,
+                                                          (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+                       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                               NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                               talloc_free(tmp_ctx);
+                               return ntstatus_to_werror(status);
+                       }
+               }
+
+               id3.dn = ldb_dn_get_linearized(dn);
+               if (strncmp(id3.dn, "B:", 2) == 0) {
+                       id3.dn = strchr(id3.dn, ':');
+                       id3.dn = strchr(id3.dn+1, ':');
+                       id3.dn = strchr(id3.dn+1, ':');
+                       id3.dn++;
+               }
+
+               /* get binary stuff */
+               ldb_dn_get_binary(dn, &id3.binary);
+
+               ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                       talloc_free(tmp_ctx);
                        return ntstatus_to_werror(status);
                }
+               talloc_free(tmp_ctx);
        }
 
        return WERR_OK;
 }
 
+
+
 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(struct ldb_context *ldb, 
                                                              const struct dsdb_schema *schema,
                                                              const struct dsdb_attribute *attr,

diff --git a/source4/heimdal/kdc/windc.c b/source4/heimdal/kdc/windc.c
index 9d7fa52ceab498c9635f4873e5b06bec26d3a764..ab844e346cf53fc6d7afe3bab7f146c5c37d6faf 100644 (file)
--- a/source4/heimdal/kdc/windc.c
+++ b/source4/heimdal/kdc/windc.c
@@ -61,8 +61,8 @@ krb5_kdc_windc_init(krb5_context context)
        (*windcft->init)(context, &windcctx);
        break;
     }
+    _krb5_plugin_free(list);
     if (e == NULL) {
-       _krb5_plugin_free(list);
        krb5_set_error_message(context, ENOENT, "Did not find any WINDC plugin");
        windcft = NULL;
        return ENOENT;

diff --git a/source4/heimdal/kuser/kinit.c b/source4/heimdal/kuser/kinit.c
index 4208fa83e0ca5eb8e89fd78d3c09370773db65bf..dd122b5ce73c4f0ec50fa973b1d8f15971be22e5 100644 (file)
--- a/source4/heimdal/kuser/kinit.c
+++ b/source4/heimdal/kuser/kinit.c
@@ -488,14 +488,14 @@ get_new_tickets(krb5_context context,
                                                addrs_flag ? FALSE : TRUE);
 
     if (renew_life == NULL && renewable_flag)
-       renewstr = "1 month";
+       asprintf(&renewstr, "1 month");
     if (renew_life)
-       renewstr = renew_life;
+       asprintf(&renewstr, "%s", renew_life);
     if (renewstr) {
        renew = parse_time (renewstr, "s");
        if (renew < 0)
            errx (1, "unparsable time: %s", renewstr);
-       
+       free(renewstr);
        krb5_get_init_creds_opt_set_renew_life (opt, renew);
     }
 

diff --git a/source4/heimdal/lib/hdb/keytab.c b/source4/heimdal/lib/hdb/keytab.c
index a557de036d0312fef289db3e5ec1fc62b4e97c53..6cab8a44f0bbfd0fec3f3817a985da62be9f8293 100644 (file)
--- a/source4/heimdal/lib/hdb/keytab.c
+++ b/source4/heimdal/lib/hdb/keytab.c
@@ -401,12 +401,12 @@ hdb_end_seq_get(krb5_context context,
 {
     struct hdb_cursor *c = cursor->data;
 
-    (c->db->hdb_close)(context, c->db);
-    (c->db->hdb_destroy)(context, c->db);
-
     if (!c->next)
        hdb_free_entry(context, &c->hdb_entry);
 
+    (c->db->hdb_close)(context, c->db);
+    (c->db->hdb_destroy)(context, c->db);
+
     free(c);
     return 0;
 }

diff --git a/source4/heimdal/lib/hx509/ca.c b/source4/heimdal/lib/hx509/ca.c
index 624d74289df701332a286aae4bbe474cf5911543..95f206f1956bcf37ff4ecb44ea33e77e602ce48e 100644 (file)
--- a/source4/heimdal/lib/hx509/ca.c
+++ b/source4/heimdal/lib/hx509/ca.c
@@ -692,7 +692,7 @@ add_utf8_san(hx509_context context,
             const heim_oid *oid,
             const char *string)
 {
-    const PKIXXmppAddr ustring = (const PKIXXmppAddr)string;
+    const PKIXXmppAddr ustring = string;
     heim_octet_string os;
     size_t size;
     int ret;

diff --git a/source4/heimdal/lib/hx509/cert.c b/source4/heimdal/lib/hx509/cert.c
index cd9ae01fac06ac23bf693296e3b52d9e50c94807..7eda0eba48689926d591e8aef194ffcf39d2eade 100644 (file)
--- a/source4/heimdal/lib/hx509/cert.c
+++ b/source4/heimdal/lib/hx509/cert.c
@@ -3383,7 +3383,6 @@ _hx509_cert_to_env(hx509_context context, hx509_cert cert, hx509_env *env)
        Certificate *c = _hx509_get_cert(cert);
         heim_octet_string os, sig;
        hx509_env envhash = NULL;
-       char *buf;
 
        os.data = c->tbsCertificate.subjectPublicKeyInfo.subjectPublicKey.data;
        os.length =

diff --git a/source4/heimdal/lib/hx509/file.c b/source4/heimdal/lib/hx509/file.c
index ba7a23f471238442067f998febf47372e84b1bc3..674d2706ce0c3d9c0919b392515ce613755db709 100644 (file)
--- a/source4/heimdal/lib/hx509/file.c
+++ b/source4/heimdal/lib/hx509/file.c
@@ -121,14 +121,14 @@ hx509_pem_write(hx509_context context, const char *type,
 
 int
 hx509_pem_add_header(hx509_pem_header **headers,
-                    const char *header, const char *value)
+                    const char *hdr, const char *value)
 {
     hx509_pem_header *h;
 
     h = calloc(1, sizeof(*h));
     if (h == NULL)
        return ENOMEM;
-    h->header = strdup(header);
+    h->header = strdup(hdr);
     if (h->header == NULL) {
        free(h);
        return ENOMEM;
@@ -164,10 +164,10 @@ hx509_pem_free_header(hx509_pem_header *headers)
  */
 
 const char *
-hx509_pem_find_header(const hx509_pem_header *h, const char *header)
+hx509_pem_find_header(const hx509_pem_header *h, const char *hdr)
 {
     while(h) {
-       if (strcmp(header, h->header) == 0)
+       if (strcmp(hdr, h->header) == 0)
            return h->value;
        h = h->next;
     }

diff --git a/source4/heimdal/lib/hx509/ks_file.c b/source4/heimdal/lib/hx509/ks_file.c
index 553191a774c918bc8e93e9624d012b88250fa7c9..3955820aef213c624c71f18bfa13cfe7b20656db 100644 (file)
--- a/source4/heimdal/lib/hx509/ks_file.c
+++ b/source4/heimdal/lib/hx509/ks_file.c
@@ -413,24 +413,24 @@ file_init_common(hx509_context context,
        goto out;
 
     for (p = f->fn; p != NULL; p = pnext) {
-       FILE *f;
+       FILE *f2;
 
        pnext = strchr(p, ',');
        if (pnext)
            *pnext++ = '\0';
        
 
-       if ((f = fopen(p, "r")) == NULL) {
+       if ((f2 = fopen(p, "r")) == NULL) {
            ret = ENOENT;
            hx509_set_error_string(context, 0, ret,
                                   "Failed to open PEM file \"%s\": %s",
                                   p, strerror(errno));
            goto out;
        }
-       rk_cloexec_file(f);
+       rk_cloexec_file(f2);
 
-       ret = hx509_pem_read(context, f, pem_func, &pem_ctx);
-       fclose(f);              
+       ret = hx509_pem_read(context, f2, pem_func, &pem_ctx);
+       fclose(f2);
        if (ret != 0 && ret != HX509_PARSING_KEY_FAILED)
            goto out;
        else if (ret == HX509_PARSING_KEY_FAILED) {

diff --git a/source4/heimdal/lib/hx509/name.c b/source4/heimdal/lib/hx509/name.c
index 23736edde3b551a11da9bcbe25a5a078257ede0f..546b7490157d36c20ca14cd17e40c8afd2d4703a 100644 (file)
--- a/source4/heimdal/lib/hx509/name.c
+++ b/source4/heimdal/lib/hx509/name.c
@@ -926,12 +926,12 @@ hx509_general_name_unparse(GeneralName *name, char **str)
 
     switch (name->element) {
     case choice_GeneralName_otherName: {
-       char *str;
-       hx509_oid_sprint(&name->u.otherName.type_id, &str);
-       if (str == NULL)
+       char *str2;
+       hx509_oid_sprint(&name->u.otherName.type_id, &str2);
+       if (str2 == NULL)
            return ENOMEM;
-       strpool = rk_strpoolprintf(strpool, "otherName: %s", str);
-       free(str);
+       strpool = rk_strpoolprintf(strpool, "otherName: %s", str2);
+       free(str2);
        break;
     }
     case choice_GeneralName_rfc822Name:
@@ -986,12 +986,12 @@ hx509_general_name_unparse(GeneralName *name, char **str)
        break;
     }
     case choice_GeneralName_registeredID: {
-       char *str;
-       hx509_oid_sprint(&name->u.registeredID, &str);
-       if (str == NULL)
+       char *str2;
+       hx509_oid_sprint(&name->u.registeredID, &str2);
+       if (str2 == NULL)
            return ENOMEM;
-       strpool = rk_strpoolprintf(strpool, "registeredID: %s", str);
-       free(str);
+       strpool = rk_strpoolprintf(strpool, "registeredID: %s", str2);
+       free(str2);
        break;
     }
     default:

diff --git a/source4/heimdal/lib/hx509/sel.c b/source4/heimdal/lib/hx509/sel.c
index 5932ce84c3d4020c24987365221ceca131a48e7c..c5e760569a9b318aa96b64b9a516cf6f09f5233b 100644 (file)
--- a/source4/heimdal/lib/hx509/sel.c
+++ b/source4/heimdal/lib/hx509/sel.c
@@ -176,6 +176,7 @@ _hx509_expr_eval(hx509_context context, hx509_env env, struct hx_expr *expr)
     default:
        _hx509_abort("hx509 eval expr with unknown op: %d", (int)expr->op);
     }
+    return 0;
 }
 
 void

diff --git a/source4/kdc/kdc.c b/source4/kdc/kdc.c
index a67aa094613fe3299110601e4ee2a396dfd244b1..1260e9000f8a0cc01a5883688dff64757b592b11 100644 (file)
--- a/source4/kdc/kdc.c
+++ b/source4/kdc/kdc.c
@@ -602,7 +602,7 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
        }
 
        ret = krb5_make_principal(kdc->smb_krb5_context->krb5_context, &principal, 
-                                 lp_realm(kdc->task->lp_ctx), 
+                                 lp_realm(kdc->task->lp_ctx),
                                  "krbtgt", lp_realm(kdc->task->lp_ctx), 
                                  NULL);
 

diff --git a/source4/kdc/kpasswdd.c b/source4/kdc/kpasswdd.c
index 9664d1b016feb10f5b5dfd4efd35cbb21da9b8b6..f9bd683e888d445466e60045a83fc848a5e1786f 100644 (file)
--- a/source4/kdc/kpasswdd.c
+++ b/source4/kdc/kpasswdd.c
@@ -113,7 +113,7 @@ static bool kpasswdd_make_unauth_error_reply(struct kdc_server *kdc,
 static bool kpasswd_make_pwchange_reply(struct kdc_server *kdc, 
                                        TALLOC_CTX *mem_ctx, 
                                        NTSTATUS status, 
-                                       enum samr_RejectReason reject_reason,
+                                       enum samPwdChangeReason reject_reason,
                                        struct samr_DomInfo1 *dominfo,
                                        DATA_BLOB *error_blob) 
 {
@@ -132,17 +132,16 @@ static bool kpasswd_make_pwchange_reply(struct kdc_server *kdc,
        if (dominfo && NT_STATUS_EQUAL(status, NT_STATUS_PASSWORD_RESTRICTION)) {
                const char *reject_string;
                switch (reject_reason) {
-               case SAMR_REJECT_TOO_SHORT:
+               case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT:
                        reject_string = talloc_asprintf(mem_ctx, "Password too short, password must be at least %d characters long",
                                                        dominfo->min_password_length);
                        break;
-               case SAMR_REJECT_COMPLEXITY:
+               case SAM_PWD_CHANGE_NOT_COMPLEX:
                        reject_string = "Password does not meet complexity requirements";
                        break;
-               case SAMR_REJECT_IN_HISTORY:
+               case SAM_PWD_CHANGE_PWD_IN_HISTORY:
                        reject_string = "Password is already in password history";
                        break;
-               case SAMR_REJECT_OTHER:
                default:
                        reject_string = talloc_asprintf(mem_ctx, "Password must be at least %d characters long, and cannot match any of your %d previous passwords",
                                                        dominfo->min_password_length, dominfo->password_history_length);
@@ -178,7 +177,7 @@ static bool kpasswdd_change_password(struct kdc_server *kdc,
                                     DATA_BLOB *reply)
 {
        NTSTATUS status;
-       enum samr_RejectReason reject_reason;
+       enum samPwdChangeReason reject_reason;
        struct samr_DomInfo1 *dominfo;
        struct ldb_context *samdb;
 
@@ -248,7 +247,7 @@ static bool kpasswd_process_request(struct kdc_server *kdc,
        case KRB5_KPASSWD_VERS_SETPW:
        {
                NTSTATUS status;
-               enum samr_RejectReason reject_reason = SAMR_REJECT_OTHER;
+               enum samPwdChangeReason reject_reason = SAM_PWD_CHANGE_NO_ERROR;
                struct samr_DomInfo1 *dominfo = NULL;
                struct ldb_context *samdb;
                struct ldb_message *msg;
@@ -349,7 +348,7 @@ static bool kpasswd_process_request(struct kdc_server *kdc,
                        status = NT_STATUS_TRANSACTION_ABORTED;
                        return kpasswd_make_pwchange_reply(kdc, mem_ctx, 
                                                           status,
-                                                          SAMR_REJECT_OTHER, 
+                                                          SAM_PWD_CHANGE_NO_ERROR,
                                                           NULL, 
                                                           reply);
                }
@@ -362,7 +361,7 @@ static bool kpasswd_process_request(struct kdc_server *kdc,
                        ldb_transaction_cancel(samdb);
                        return kpasswd_make_pwchange_reply(kdc, mem_ctx, 
                                                           status,
-                                                          SAMR_REJECT_OTHER, 
+                                                          SAM_PWD_CHANGE_NO_ERROR,
                                                           NULL, 
                                                           reply);
                }

diff --git a/source4/ldap_server/ldap_backend.c b/source4/ldap_server/ldap_backend.c
index 27b9c879bba25d10b4034e9ceacf81a8b8762335..f3d82a7bc4b6a53bd1cecc5d1d07975c8b7c78ee 100644 (file)
--- a/source4/ldap_server/ldap_backend.c
+++ b/source4/ldap_server/ldap_backend.c
@@ -534,26 +534,11 @@ static NTSTATUS ldapsrv_ModifyRequest(struct ldapsrv_call *call)
                                NT_STATUS_HAVE_NO_MEMORY(msg->elements[i].values);
 
                                for (j=0; j < msg->elements[i].num_values; j++) {
-                                       if (!(req->mods[i].attrib.values[j].length > 0)) {
-                                               result = LDAP_OTHER;
-
-                                               map_ldb_error(local_ctx,
-                                                       LDB_ERR_OTHER, &errstr);
-                                               errstr = talloc_asprintf(local_ctx,
-                                                       "%s. Empty attribute values not allowed", errstr);
-                                               goto reply;
-                                       }
                                        msg->elements[i].values[j].length = req->mods[i].attrib.values[j].length;
                                        msg->elements[i].values[j].data = req->mods[i].attrib.values[j].data;                   
                                }
                        }
                }
-       } else {
-               result = LDAP_OTHER;
-               map_ldb_error(local_ctx, LDB_ERR_OTHER, &errstr);
-               errstr = talloc_asprintf(local_ctx,
-                       "%s. No mods are not allowed", errstr);
-               goto reply;
        }
 
 reply:
@@ -628,31 +613,11 @@ static NTSTATUS ldapsrv_AddRequest(struct ldapsrv_call *call)
                                NT_STATUS_HAVE_NO_MEMORY(msg->elements[i].values);
 
                                for (j=0; j < msg->elements[i].num_values; j++) {
-                                       if (!(req->attributes[i].values[j].length > 0)) {
-                                               result = LDAP_OTHER;
-                                               map_ldb_error(local_ctx,
-                                                       LDB_ERR_OTHER, &errstr);
-                                               errstr = talloc_asprintf(local_ctx,
-                                                       "%s. Empty attribute values not allowed", errstr);
-                                               goto reply;
-                                       }
                                        msg->elements[i].values[j].length = req->attributes[i].values[j].length;
                                        msg->elements[i].values[j].data = req->attributes[i].values[j].data;                    
                                }
-                       } else {
-                               result = LDAP_OTHER;
-                               map_ldb_error(local_ctx, LDB_ERR_OTHER, &errstr);
-                               errstr = talloc_asprintf(local_ctx,
-                                       "%s. No attribute values are not allowed", errstr);
-                               goto reply;
                        }
                }
-       } else {
-               result = LDAP_OTHER;
-               map_ldb_error(local_ctx, LDB_ERR_OTHER, &errstr);
-               errstr = talloc_asprintf(local_ctx, 
-                       "%s. No attributes are not allowed", errstr);
-               goto reply;
        }
 
 reply:
@@ -750,6 +715,12 @@ static NTSTATUS ldapsrv_ModifyDNRequest(struct ldapsrv_call *call)
        DEBUG(10, ("ModifyDNRequest: olddn: [%s]\n", req->dn));
        DEBUG(10, ("ModifyDNRequest: newrdn: [%s]\n", req->newrdn));
 
+       if (ldb_dn_get_comp_num(newrdn) != 1) {
+               result = LDAP_INVALID_DN_SYNTAX;
+               map_ldb_error(local_ctx, LDB_ERR_INVALID_DN_SYNTAX, &errstr);
+               goto reply;
+       }
+
        /* we can't handle the rename if we should not remove the old dn */
        if (!req->deleteolddn) {
                result = LDAP_UNWILLING_TO_PERFORM;
@@ -779,10 +750,7 @@ static NTSTATUS ldapsrv_ModifyDNRequest(struct ldapsrv_call *call)
                NT_STATUS_HAVE_NO_MEMORY(parentdn);
        }
 
-       if ( ! ldb_dn_add_child_fmt(parentdn,
-                               "%s=%s",
-                               ldb_dn_get_rdn_name(newrdn),
-                               (char *)ldb_dn_get_rdn_val(newrdn)->data)) {
+       if ( ! ldb_dn_add_child(parentdn, newrdn)) {
                result = LDAP_OTHER;
                goto reply;
        }

diff --git a/source4/lib/com/main.c b/source4/lib/com/main.c
index 062d1360ac823b94cfcf18a94b7b3fb5cc90ad87..487ed5b712d002d4e44927bb59302359df1c3eda 100644 (file)
--- a/source4/lib/com/main.c
+++ b/source4/lib/com/main.c
@@ -52,7 +52,7 @@ WERROR com_create_object(struct com_context *ctx, struct GUID *clsid, int num_if
        }
 
        /* Run IClassFactory::CreateInstance() */
-       error = IClassFactory_CreateInstance(factory, ctx, NULL, &classfact_iid, &iunk);
+       error = IClassFactory_CreateInstance(factory, ctx, NULL, &classfact_iid, (struct MInterfacePointer *) &iunk);
        if (!W_ERROR_IS_OK(error)) {
                DEBUG(3, ("Error while calling IClassFactory::CreateInstance : %s\n", win_errstr(error)));
                return error;

diff --git a/source4/lib/ldb-samba/ldif_handlers.c b/source4/lib/ldb-samba/ldif_handlers.c
index 43a10450d1cb3689af2f5a7ba6143d4151047012..59f8622a376a1d452a45dac0cecab1feb6f80b2e 100644 (file)
--- a/source4/lib/ldb-samba/ldif_handlers.c
+++ b/source4/lib/ldb-samba/ldif_handlers.c
@@ -33,6 +33,7 @@
 #include "librpc/ndr/libndr.h"
 #include "libcli/security/security.h"
 #include "param/param.h"
+#include "../lib/util/asn1.h"
 
 /*
   use ndr_print_* to convert a NDR formatted blob to a ldif formatted blob
@@ -507,6 +508,7 @@ static int ldif_read_prefixMap(struct ldb_context *ldb, void *mem_ctx,
        struct prefixMapBlob *blob;
        enum ndr_err_code ndr_err;
        char *string, *line, *p, *oid;
+       DATA_BLOB oid_blob;
 
        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 
@@ -563,8 +565,12 @@ static int ldif_read_prefixMap(struct ldb_context *ldb, void *mem_ctx,
                /* we know there must be at least ":" */
                oid++;
 
-               blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.oid
-                       = talloc_strdup(blob->ctr.dsdb.mappings, oid);
+               if (!ber_write_partial_OID_String(blob->ctr.dsdb.mappings, &oid_blob, oid)) {
+                       talloc_free(tmp_ctx);
+                       return -1;
+               }
+               blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.length = oid_blob.length;
+               blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.binary_oid = oid_blob.data;
 
                blob->ctr.dsdb.num_mappings++;
 
@@ -615,32 +621,47 @@ static int ldif_write_prefixMap(struct ldb_context *ldb, void *mem_ctx,
                                           blob,
                                           (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-               talloc_free(blob);
-               return -1;
+               goto failed;
        }
        if (blob->version != PREFIX_MAP_VERSION_DSDB) {
-               return -1;
+               goto failed;
        }
        string = talloc_strdup(mem_ctx, "");
        if (string == NULL) {
-               return -1;
+               goto failed;
        }
 
        for (i=0; i < blob->ctr.dsdb.num_mappings; i++) {
+               DATA_BLOB oid_blob;
+               const char *partial_oid = NULL;
+
                if (i > 0) {
                        string = talloc_asprintf_append(string, ";"); 
                }
+
+               oid_blob = data_blob_const(blob->ctr.dsdb.mappings[i].oid.binary_oid,
+                                          blob->ctr.dsdb.mappings[i].oid.length);
+               if (!ber_read_partial_OID_String(blob, oid_blob, &partial_oid)) {
+                       DEBUG(0, ("ber_read_partial_OID failed on prefixMap item with id: 0x%X",
+                                 blob->ctr.dsdb.mappings[i].id_prefix));
+                       goto failed;
+               }
                string = talloc_asprintf_append(string, "%u:%s", 
                                                   blob->ctr.dsdb.mappings[i].id_prefix,
-                                                  blob->ctr.dsdb.mappings[i].oid.oid);
+                                                  partial_oid);
+               talloc_free(discard_const(partial_oid));
                if (string == NULL) {
-                       return -1;
+                       goto failed;
                }
        }
 
        talloc_free(blob);
        *out = data_blob_string_const(string);
        return 0;
+
+failed:
+       talloc_free(blob);
+       return -1;
 }
 
 static bool ldif_comparision_prefixMap_isString(const struct ldb_val *v)
@@ -756,7 +777,7 @@ static int ldif_write_replUpToDateVector(struct ldb_context *ldb, void *mem_ctx,
        return ldif_write_NDR(ldb, mem_ctx, in, out, 
                              sizeof(struct replUpToDateVectorBlob),
                              (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob,
-                             (ndr_print_fn_t)ndr_print_replPropertyMetaDataBlob);
+                             (ndr_print_fn_t)ndr_print_replUpToDateVectorBlob);
 }
 
 

diff --git a/source4/lib/ldb/common/ldb_controls.c b/source4/lib/ldb/common/ldb_controls.c
index b38373ec12f38543d6886eefd30959fdbb90efaa..a8dd6b585984a0b3c3fcfb9e9eebafad37229bf6 100644 (file)
--- a/source4/lib/ldb/common/ldb_controls.c
+++ b/source4/lib/ldb/common/ldb_controls.c
@@ -123,7 +123,7 @@ int check_critical_controls(struct ldb_control **controls)
 
 int ldb_request_add_control(struct ldb_request *req, const char *oid, bool critical, void *data)
 {
-       unsigned n;
+       unsigned i, n;
        struct ldb_control **ctrls;
        struct ldb_control *ctrl;
 
@@ -135,10 +135,15 @@ int ldb_request_add_control(struct ldb_request *req, const char *oid, bool criti
                n++; 
        }
 
-       ctrls = talloc_realloc(req, req->controls,
+       ctrls = talloc_array(req,
                               struct ldb_control *,
                               n + 2);
        if (!ctrls) return LDB_ERR_OPERATIONS_ERROR;
+
+       for (i=0; i<n; i++) {
+               ctrls[i] = req->controls[i];
+       }
+
        req->controls = ctrls;
        ctrls[n] = NULL;
        ctrls[n+1] = NULL;
@@ -407,6 +412,33 @@ struct ldb_control **ldb_parse_control_strings(struct ldb_context *ldb, void *me
                        continue;
                }
 
+               if (strncmp(control_strings[i], "relax:", 6) == 0) {
+                       const char *p;
+                       int crit, ret;
+
+                       p = &(control_strings[i][6]);
+                       ret = sscanf(p, "%d", &crit);
+                       if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                               error_string = talloc_asprintf(mem_ctx, "invalid relax control syntax\n");
+                               error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                               error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                               ldb_set_errstring(ldb, error_string);
+                               talloc_free(error_string);
+                               return NULL;
+                       }
+
+                       ctrl[i] = talloc(ctrl, struct ldb_control);
+                       if (!ctrl[i]) {
+                               ldb_oom(ldb);
+                               return NULL;
+                       }
+                       ctrl[i]->oid = LDB_CONTROL_RELAX_OID;
+                       ctrl[i]->critical = crit;
+                       ctrl[i]->data = NULL;
+
+                       continue;
+               }
+
                if (strncmp(control_strings[i], "domain_scope:", 13) == 0) {
                        const char *p;
                        int crit, ret;

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 12a513fc429992fb2e6aa4ce3d5be354d5919406..fa3865e77f42daee248b4c4a8586b99c1a9f5d2d 100644 (file)
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -77,8 +77,17 @@ struct ldb_dn {
 
        unsigned int ext_comp_num;
        struct ldb_dn_ext_component *ext_components;
+
+       char extra_type;
+       struct ldb_val extra_val;
 };
 
+/* it is helpful to be able to break on this in gdb */
+static void ldb_dn_mark_invalid(struct ldb_dn *dn)
+{
+       dn->invalid = true;
+}
+
 /* strdn may be NULL */
 struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx,
                                    struct ldb_context *ldb,
@@ -94,6 +103,13 @@ struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx,
                return NULL;
        }
 
+       /* if the DN starts with B: then it has a binary blob
+        * attached. Called the binary dn parser, which will call back
+        * here for the rest of the DN */
+       if (strdn->data && strncmp((char *)strdn->data, "B:", 2) == 0) {
+               return ldb_dn_binary_from_ldb_val(mem_ctx, ldb, strdn);
+       }
+
        dn = talloc_zero(mem_ctx, struct ldb_dn);
        LDB_DN_NULL_FAILED(dn);
 
@@ -141,13 +157,180 @@ failed:
        return NULL;
 }
 
+/*
+  a version of strhex_to_str internal to ldb, for use by the binary
+  ldb code
+ */
+static size_t ldb_strhex_to_str(char *p, size_t p_len, const char *strhex, 
+                               size_t strhex_len)
+{
+       size_t i;
+       size_t num_chars = 0;
+       uint8_t   lonybble, hinybble;
+       const char     *hexchars = "0123456789ABCDEF";
+       char           *p1 = NULL, *p2 = NULL;
+
+       for (i = 0; i < strhex_len && strhex[i] != 0; i++) {
+               if (!(p1 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
+                       break;
+
+               i++; /* next hex digit */
+
+               if (!(p2 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
+                       break;
+
+               /* get the two nybbles */
+               hinybble = PTR_DIFF(p1, hexchars);
+               lonybble = PTR_DIFF(p2, hexchars);
+
+               if (num_chars >= p_len) {
+                       break;
+               }
+
+               p[num_chars] = (hinybble << 4) | lonybble;
+               num_chars++;
+
+               p1 = NULL;
+               p2 = NULL;
+       }
+       return num_chars;
+}
+
+/* strdn may be NULL */
+struct ldb_dn *ldb_dn_binary_from_ldb_val(void *mem_ctx,
+                                         struct ldb_context *ldb,
+                                         const struct ldb_val *strdn)
+{
+       struct ldb_dn *dn;
+       const char *data;
+       size_t len;
+       char *linearized;
+       TALLOC_CTX *tmp_ctx;
+       char *p1;
+       char *p2;
+       uint32_t blen;
+       struct ldb_val bval;
+       struct ldb_val dval;
+       char *dn_str;
+       char *old;
+
+       if (strdn && strdn->data
+           && (strlen((const char*)strdn->data) != strdn->length)) {
+               /* The RDN must not contain a character with value 0x0 */
+               return NULL;
+       }
+
+       if (!strdn->data || strdn->length == 0) {
+               return NULL;
+
+       }
+
+       tmp_ctx = talloc_new(mem_ctx);
+       if (tmp_ctx == NULL) {
+               return NULL;
+       }
+
+       data = (const char *)strdn->data;
+
+       if (data[0] != 'B') {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": no prefix?\n");
+               return NULL;
+       }
+
+       len = strdn->length;
+       linearized = talloc_strndup(tmp_ctx, data, len);
+       if (linearized == NULL) {
+               goto failed;
+       }
+
+       ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": processing DN '%s'\n", linearized);
+
+       p1 = linearized;
+
+       p1++; len--;
+       
+       if (p1[0] != ':') {
+               goto failed;
+       }
+       p1++;
+       len--;
+       
+       errno = 0;
+       blen = strtoul(p1, &p2, 10);
+       if (errno != 0) {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": failed\n");
+               goto failed;
+       }
+       if (p2 == NULL) {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": failed\n");
+               goto failed;
+       }
+       if (p2[0] != ':') {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": failed\n");
+               goto failed;
+       }
+       len -= PTR_DIFF(p2,p1);//???
+       p1 = p2+1;
+       len--;
+       
+       if (blen >= len) {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": blen=%u len=%u\n", (unsigned)blen, (unsigned)len);
+               goto failed;
+       }
+
+       p2 = p1 + blen;
+       if (p2[0] != ':') {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": %s", p2);
+               goto failed;
+       }
+       dn_str = p2+1;
+       
+       bval.length = (blen/2)+1;
+       bval.data = talloc_size(tmp_ctx, bval.length);
+       if (bval.data == NULL) {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": err\n");
+               goto failed;
+       }
+       bval.data[bval.length-1] = 0;
+       
+       bval.length = ldb_strhex_to_str((char *)bval.data, bval.length,
+                                       p1, blen);
+       
+       dval.data = (uint8_t *)dn_str;
+       dval.length = strlen(dn_str);
+       
+       dn = ldb_dn_from_ldb_val(mem_ctx, ldb, &dval);
+       if (dn == NULL) {
+               ldb_debug(ldb, LDB_DEBUG_TRACE, __location__ ": err\n");
+               goto failed;
+       }
+       dn->extra_type = data[0];
+       dn->extra_val = bval;
+       talloc_steal(dn, bval.data);
+
+       *dn_str = '\0';
+       old = dn->linearized;
+       dn->linearized = talloc_asprintf(dn, "%s%s", linearized, dn->linearized);
+       talloc_free(old);
+       if (dn->ext_linearized) {
+               old = dn->ext_linearized;
+               dn->ext_linearized = talloc_asprintf(dn, "%s%s", linearized, dn->ext_linearized);
+               talloc_free(old);
+       }
+       
+       return dn;
+failed:
+       talloc_free(tmp_ctx);
+       return NULL;
+}
+
 /* strdn may be NULL */
 struct ldb_dn *ldb_dn_new(void *mem_ctx,
                          struct ldb_context *ldb,
                          const char *strdn)
 {
        struct ldb_val blob;
-       blob.data = strdn;
+       blob.data = discard_const_p(uint8_t, strdn);
        blob.length = strdn ? strlen(strdn) : 0;
        return ldb_dn_from_ldb_val(mem_ctx, ldb, &blob);
 }
@@ -273,9 +456,12 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
                return false;
        }
 
-       /* The RDN size must be less than 255 characters */
-       if (strlen(parse_dn) > 255) {
-               return false;
+
+       if (strncmp(parse_dn, "B:", 2) == 0) {
+               parse_dn = strchr(parse_dn, ':');
+               parse_dn = strchr(parse_dn+1, ':');
+               parse_dn = strchr(parse_dn+1, ':');
+               parse_dn++;
        }
 
        /* Empty DNs */
@@ -383,7 +569,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
                                ret = ext_syntax->read_fn(dn->ldb, dn->ext_components,
                                                          &ex_val, &dn->ext_components[dn->ext_comp_num].value);
                                if (ret != LDB_SUCCESS) {
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        goto failed;
                                }
 
@@ -398,7 +584,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
                                        p++;
                                        continue;
                                } else {
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        goto failed;
                                }
                        }
@@ -418,7 +604,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
                                if (!isascii(*p)) {
                                        /* attr names must be ascii only */
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        goto failed;
                                }
 
@@ -428,7 +614,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
                                if ( ! isalpha(*p)) {
                                        /* not a digit nor an alpha,
                                         * invalid attribute name */
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        goto failed;
                                }
 
@@ -447,7 +633,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
                        if (trim && (*p != '=')) {
                                /* spaces/tabs are not allowed */
-                               dn->invalid = true;
+                               ldb_dn_mark_invalid(dn);
                                goto failed;
                        }
 
@@ -476,19 +662,19 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
                        if (!isascii(*p)) {
                                /* attr names must be ascii only */
-                               dn->invalid = true;
+                               ldb_dn_mark_invalid(dn);
                                goto failed;
                        }
 
                        if (is_oid && ( ! (isdigit(*p) || (*p == '.')))) {
                                /* not a digit nor a dot,
                                 * invalid attribute oid */
-                               dn->invalid = true;
+                               ldb_dn_mark_invalid(dn);
                                goto failed;
                        } else
                        if ( ! (isalpha(*p) || isdigit(*p) || (*p == '-'))) {
                                /* not ALPHA, DIGIT or HYPHEN */
-                               dn->invalid = true;
+                               ldb_dn_mark_invalid(dn);
                                goto failed;
                        }
 
@@ -588,7 +774,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
                        case '\"':
                                /* a string with not escaped specials is invalid (tested) */
                                if ( ! escape) {
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        goto failed;
                                }
                                escape = false;
@@ -617,7 +803,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
                                if (escape) {
                                        if (sscanf(p, "%02x", &x) != 1) {
                                                /* invalid escaping sequence */
-                                               dn->invalid = true;
+                                               ldb_dn_mark_invalid(dn);
                                                goto failed;
                                        }
                                        escape = false;
@@ -647,7 +833,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
        if (in_attr || in_quote) {
                /* invalid dn */
-               dn->invalid = true;
+               ldb_dn_mark_invalid(dn);
                goto failed;
        }
 
@@ -683,20 +869,45 @@ bool ldb_dn_validate(struct ldb_dn *dn)
        return ldb_dn_explode(dn);
 }
 
+static char *data_blob_hex_string_upper(TALLOC_CTX *mem_ctx, const struct ldb_val *blob)
+{
+       int i;
+       char *hex_string;
+
+       hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
+       if (!hex_string) {
+               return NULL;
+       }
+
+       for (i = 0; i < blob->length; i++)
+               slprintf(&hex_string[i*2], 3, "%02X", blob->data[i]);
+
+       hex_string[(blob->length*2)] = '\0';
+       return hex_string;
+}
+
+
 const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 {
        int i, len;
        char *d, *n;
+       char *extra_prefix = NULL;
 
        if ( ! dn || ( dn->invalid)) return NULL;
 
        if (dn->linearized) return dn->linearized;
 
        if ( ! dn->components) {
-               dn->invalid = true;
+               ldb_dn_mark_invalid(dn);
                return NULL;
        }
 
+       if (dn->extra_type == 'B') {
+               char *hexstr = data_blob_hex_string_upper(dn, &dn->extra_val);
+               extra_prefix = talloc_asprintf(dn, "B:%u:%s:", (unsigned)(dn->extra_val.length*2), hexstr);
+               talloc_free(hexstr);
+       }
+
        if (dn->comp_num == 0) {
                dn->linearized = talloc_strdup(dn, "");
                if ( ! dn->linearized) return NULL;
@@ -737,13 +948,20 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
        dn->linearized = talloc_realloc(dn, dn->linearized,
                                        char, (d - dn->linearized + 1));
 
+       if (extra_prefix) {
+               char *old = dn->linearized;
+               dn->linearized = talloc_asprintf(dn, "%s%s", extra_prefix, old);
+               talloc_free(old);
+               talloc_free(extra_prefix);
+       }
+
        return dn->linearized;
 }
 
 char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode)
 {
        const char *linearized = ldb_dn_get_linearized(dn);
-       char *p;
+       char *p = NULL;
        int i;
 
        if (!linearized) {
@@ -758,6 +976,14 @@ char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode)
                return NULL;
        }
 
+       if (dn->extra_type == 'B') {
+               char *hexstr = data_blob_hex_string_upper(mem_ctx, &dn->extra_val);
+               p = talloc_asprintf(mem_ctx, "B:%u:%s:", (unsigned)(dn->extra_val.length*2), hexstr);
+               talloc_free(hexstr);
+       } else {
+               p = talloc_strdup(mem_ctx, "");
+       }
+
        for (i = 0; i < dn->ext_comp_num; i++) {
                const struct ldb_dn_extended_syntax *ext_syntax;
                const char *name = dn->ext_components[i].name;
@@ -782,11 +1008,9 @@ char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode)
                }
 
                if (i == 0) {
-                       p = talloc_asprintf(mem_ctx, "<%s=%s>",
-                                                       name, val.data);
+                       p = talloc_asprintf_append_buffer(p, "<%s=%s>", name, val.data);
                } else {
-                       p = talloc_asprintf_append(p, ";<%s=%s>",
-                                                       name, val.data);
+                       p = talloc_asprintf_append_buffer(p, ";<%s=%s>",name, val.data);
                }
 
                talloc_free(val.data);
@@ -797,7 +1021,13 @@ char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode)
        }
 
        if (dn->ext_comp_num && *linearized) {
-               p = talloc_asprintf_append(p, ";%s", linearized);
+               if (strncmp(linearized, "B:", 2) == 0) {
+                       linearized = strchr(linearized, ':');
+                       linearized = strchr(linearized+1, ':');
+                       linearized = strchr(linearized+1, ':');
+                       linearized++;
+               }
+               p = talloc_asprintf_append_buffer(p, ";%s", linearized);
        }
 
        if (!p) {
@@ -1287,7 +1517,7 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
                                                struct ldb_dn_component,
                                                dn->comp_num + base->comp_num);
                if ( ! dn->components) {
-                       dn->invalid = true;
+                       ldb_dn_mark_invalid(dn);
                        return false;
                }
 
@@ -1296,7 +1526,7 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
                                ldb_dn_copy_component(dn->components,
                                                        &base->components[i]);
                        if (dn->components[dn->comp_num].value.data == NULL) {
-                               dn->invalid = true;
+                               ldb_dn_mark_invalid(dn);
                                return false;
                        }
                }
@@ -1327,7 +1557,7 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
                        t = talloc_strdup(dn, s);
                }
                if ( ! t) {
-                       dn->invalid = true;
+                       ldb_dn_mark_invalid(dn);
                        return false;
                }
                LDB_FREE(dn->linearized);
@@ -1413,7 +1643,7 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
                                                struct ldb_dn_component,
                                                n);
                if ( ! dn->components) {
-                       dn->invalid = true;
+                       ldb_dn_mark_invalid(dn);
                        return false;
                }
 
@@ -1426,7 +1656,7 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
                                ldb_dn_copy_component(dn->components,
                                                        &child->components[i]);
                        if (dn->components[i].value.data == NULL) {
-                               dn->invalid = true;
+                               ldb_dn_mark_invalid(dn);
                                return false;
                        }
                }
@@ -1449,7 +1679,7 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
 
                t = talloc_asprintf(dn, "%s,%s", s, dn->linearized);
                if ( ! t) {
-                       dn->invalid = true;
+                       ldb_dn_mark_invalid(dn);
                        return false;
                }
                LDB_FREE(dn->linearized);
@@ -1818,7 +2048,7 @@ int ldb_dn_set_extended_component(struct ldb_dn *dn,
                                        talloc_strdup(dn->ext_components, name);
                                if (!dn->ext_components[i].name ||
                                    !dn->ext_components[i].value.data) {
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        return LDB_ERR_OPERATIONS_ERROR;
                                }
 
@@ -1836,7 +2066,7 @@ int ldb_dn_set_extended_component(struct ldb_dn *dn,
                                                   struct ldb_dn_ext_component,
                                                   dn->ext_comp_num);
                                if (!dn->ext_components) {
-                                       dn->invalid = true;
+                                       ldb_dn_mark_invalid(dn);
                                        return LDB_ERR_OPERATIONS_ERROR;
                                }
                                return LDB_SUCCESS;
@@ -1850,7 +2080,7 @@ int ldb_dn_set_extended_component(struct ldb_dn *dn,
                                 struct ldb_dn_ext_component,
                                 dn->ext_comp_num + 1);
        if (!dn->ext_components) {
-               dn->invalid = true;
+               ldb_dn_mark_invalid(dn);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -1858,7 +2088,7 @@ int ldb_dn_set_extended_component(struct ldb_dn *dn,
        p[dn->ext_comp_num].name = talloc_strdup(p, name);
 
        if (!dn->ext_components[i].name || !dn->ext_components[i].value.data) {
-               dn->invalid = true;
+               ldb_dn_mark_invalid(dn);
                return LDB_ERR_OPERATIONS_ERROR;
        }
        dn->ext_components = p;
@@ -1888,7 +2118,7 @@ bool ldb_dn_is_special(struct ldb_dn *dn)
 bool ldb_dn_has_extended(struct ldb_dn *dn)
 {
        if ( ! dn || dn->invalid) return false;
-       if (dn->ext_linearized && (dn->ext_linearized[0] == '<')) return true;
+       if (dn->ext_linearized && strchr(dn->ext_linearized,'<')) return true;
        return dn->ext_comp_num != 0;
 }
 
@@ -1905,3 +2135,26 @@ bool ldb_dn_is_null(struct ldb_dn *dn)
        if (dn->linearized && (dn->linearized[0] == '\0')) return true;
        return false;
 }
+
+int ldb_dn_get_binary(struct ldb_dn *dn, struct ldb_val *val)
+{
+       ZERO_STRUCTP(val);
+       if (dn->extra_type != 'B') {
+               return LDB_SUCCESS;
+       }
+       *val = dn->extra_val;
+       return LDB_SUCCESS;
+}
+
+int ldb_dn_set_binary(struct ldb_dn *dn, struct ldb_val *val)
+{
+       dn->extra_type = 'B';
+       dn->extra_val.data = talloc_memdup(dn, val->data, val->length);
+       dn->extra_val.length = val->length;
+
+       talloc_free(dn->linearized);
+       talloc_free(dn->ext_linearized);
+       dn->linearized = NULL;
+       dn->ext_linearized = NULL;
+       return LDB_SUCCESS;
+}

diff --git a/source4/lib/ldb/common/ldb_modules.c b/source4/lib/ldb/common/ldb_modules.c
index ea29a09a2ab6703b99010f62c2a94f51105d7112..69b8ed0bf4123162c3a5f935c306b2cb182f1d41 100644 (file)
--- a/source4/lib/ldb/common/ldb_modules.c
+++ b/source4/lib/ldb/common/ldb_modules.c
@@ -96,6 +96,12 @@ const char **ldb_modules_list_from_string(struct ldb_context *ldb, TALLOC_CTX *m
        }
        talloc_steal(modules, modstr);
 
+       if (modstr[0] == '\0') {
+               modules[0] = NULL;
+               m = (const char **)modules;
+               return m;
+       }
+
        i = 0;
        /* The str*r*chr walks backwards:  This is how we get the inverse order mentioned above */
        while ((p = strrchr(modstr, ',')) != NULL) {
@@ -331,7 +337,7 @@ int ldb_load_modules_list(struct ldb_context *ldb, const char **module_list, str
 
        module = backend;
 
-       for (i = 0; module_list[i] != NULL; i++) {
+       for (i = 0; module_list && module_list[i] != NULL; i++) {
                struct ldb_module *current;
                const struct ldb_module_ops *ops;
 

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 702978a3611e1d78e315b294b260e63c93d802f0..929f24cd88da4dbc7e3e4633789a1fe6c2855ba6 100644 (file)
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -560,6 +560,9 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
        unsigned int i;
 
        mod = ldb_msg_new(ldb);
+       if (mod == NULL) {
+               return NULL;
+       }
 
        mod->dn = msg1->dn;
        mod->num_elements = 0;
@@ -567,6 +570,7 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 
        msg2 = ldb_msg_canonicalize(ldb, msg2);
        if (msg2 == NULL) {
+               talloc_free(mod);
                return NULL;
        }
        
@@ -581,7 +585,8 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 
                if (ldb_msg_add(mod, 
                                &msg2->elements[i],
-                               el?LDB_FLAG_MOD_REPLACE:LDB_FLAG_MOD_ADD) != 0) {
+                               el?LDB_FLAG_MOD_REPLACE:LDB_FLAG_MOD_ADD) != LDB_SUCCESS) {
+                       talloc_free(mod);
                        return NULL;
                }
        }
@@ -589,10 +594,11 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
        /* look in msg1 to find elements that need to be deleted */
        for (i=0;i<msg1->num_elements;i++) {
                el = ldb_msg_find_element(msg2, msg1->elements[i].name);
-               if (!el) {
+               if (el == NULL) {
                        if (ldb_msg_add_empty(mod, 
                                              msg1->elements[i].name,
-                                             LDB_FLAG_MOD_DELETE, NULL) != 0) {
+                                             LDB_FLAG_MOD_DELETE, NULL) != LDB_SUCCESS) {
+                               talloc_free(mod);
                                return NULL;
                        }
                }

diff --git a/source4/lib/ldb/include/ldb.h b/source4/lib/ldb/include/ldb.h
index a08369607397353b94bdeebb453d4ac587f0bdde..69d052b0ebc42be090130fb2ded8d3a716dbba2a 100644 (file)
--- a/source4/lib/ldb/include/ldb.h
+++ b/source4/lib/ldb/include/ldb.h
@@ -456,6 +456,14 @@ const struct ldb_dn_extended_syntax *ldb_dn_extended_syntax_by_name(struct ldb_c
 /* sorting helpers */
 typedef int (*ldb_qsort_cmp_fn_t) (void *v1, void *v2, void *opaque);
 
+/**
+   OID for the allowing client to request temporary relaxed 
+   enforcement of constraints of the x.500 model.
+
+   \sa <a href="http://opends.dev.java.net/public/standards/draft-zeilenga-ldap-managedit.txt">draft managedit</a>.
+*/
+#define LDB_CONTROL_RELAX_OID "1.3.6.1.4.1.4203.666.5.12"
+
 /**
    OID for the paged results control. This control is included in the
    searchRequest and searchResultDone messages as part of the controls
@@ -588,21 +596,47 @@ typedef int (*ldb_qsort_cmp_fn_t) (void *v1, void *v2, void *opaque);
 */
 #define LDB_CONTROL_PERMISSIVE_MODIFY_OID      "1.2.840.113556.1.4.1413"
 
+/** 
+    OID to allow the server to be more 'fast and loose' with the data being added.  
+
+    \sa 
+
+*/
+#define LDB_CONTROL_SERVER_LAZY_COMMIT   "1.2.840.113556.1.4.619"
+
+/**
+   OID for LDAP Extended Operation FAST_BIND
+
+   This Extended operations is used to perform a fast bind.
+*/
+#define LDB_EXTENDED_FAST_BIND_OID     "1.2.840.113556.1.4.1781"
+
 /**
    OID for LDAP Extended Operation START_TLS.
 
-   This Extended operation is used to start a new TLS
-   channel on top of a clear text channel.
+   This Extended operation is used to start a new TLS channel on top of a clear
+   text channel.
 */
 #define LDB_EXTENDED_START_TLS_OID     "1.3.6.1.4.1.1466.20037"
 
 /**
+   OID for LDAP Extended Operation DYNAMIC_REFRESH.
+
+   This Extended operation is used to create and maintain objects which exist
+   only a specific time, e.g. when a certain client or a certain person is
+   logged in. Data refreshes have to be periodically sent in a specific
+   interval. Otherwise the entry is going to be removed.
 */
 #define LDB_EXTENDED_DYNAMIC_OID       "1.3.6.1.4.1.1466.101.119.1"
 
-/**
+/*
+   OID for LDAP Extended Operation PASSWORD_CHANGE.
+
+   This Extended operation is used to allow user password changes by the user
+   itself.
 */
-#define LDB_EXTENDED_FAST_BIND_OID     "1.2.840.113556.1.4.1781"
+#define LDB_EXTENDED_PASSWORD_CHANGE_OID       "1.3.6.1.4.1.4203.1.11.1"
+
 
 struct ldb_sd_flags_control {
        /*
@@ -1928,4 +1962,11 @@ unsigned int ldb_get_flags(struct ldb_context *ldb);
 void ldb_set_flags(struct ldb_context *ldb, unsigned flags);
 
 
+struct ldb_dn *ldb_dn_binary_from_ldb_val(void *mem_ctx,
+                                         struct ldb_context *ldb,
+                                         const struct ldb_val *strdn);
+
+int ldb_dn_get_binary(struct ldb_dn *dn, struct ldb_val *val);
+int ldb_dn_set_binary(struct ldb_dn *dn, struct ldb_val *val);
+
 #endif

diff --git a/source4/lib/ldb/ldb_ildap/ldb_ildap.c b/source4/lib/ldb/ldb_ildap/ldb_ildap.c
index ffde048223f318a12583ff02aa6f286d65110c43..352b7696d698fa47492bfb6b93e2de4f54e1368f 100644 (file)
--- a/source4/lib/ldb/ldb_ildap/ldb_ildap.c
+++ b/source4/lib/ldb/ldb_ildap/ldb_ildap.c
@@ -591,6 +591,8 @@ static int ildb_rename(struct ildb_context *ac)
 {
        struct ldb_request *req = ac->req;
        struct ldap_message *msg;
+       const char *rdn_name;
+       const struct ldb_val *rdn_val;
 
        msg = new_ldap_message(req);
        if (msg == NULL) {
@@ -604,10 +606,16 @@ static int ildb_rename(struct ildb_context *ac)
                return LDB_ERR_INVALID_DN_SYNTAX;
        }
 
-       msg->r.ModifyDNRequest.newrdn =
-               talloc_asprintf(msg, "%s=%s",
-                               ldb_dn_get_rdn_name(req->op.rename.newdn),
-                               ldb_dn_escape_value(msg, *ldb_dn_get_rdn_val(req->op.rename.newdn)));
+       rdn_name = ldb_dn_get_rdn_name(req->op.rename.newdn);
+       rdn_val = ldb_dn_get_rdn_val(req->op.rename.newdn);
+
+       if ((rdn_name != NULL) && (rdn_val != NULL)) {
+               msg->r.ModifyDNRequest.newrdn =
+                       talloc_asprintf(msg, "%s=%s", rdn_name,
+                               ldb_dn_escape_value(msg, *rdn_val));
+       } else {
+               msg->r.ModifyDNRequest.newrdn = talloc_strdup(msg, "");
+       }
        if (msg->r.ModifyDNRequest.newrdn == NULL) {
                talloc_free(msg);
                return LDB_ERR_OPERATIONS_ERROR;

diff --git a/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c b/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c
index d0573d389e91e7b8241b5e375d41a09efb232378..7e420e4ceb07571b04d23fac672c0a70400b5809 100644 (file)
--- a/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c
+++ b/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c
@@ -1053,6 +1053,19 @@ static int lsql_add(struct lsql_context *ctx)
 
                a = ldb_schema_attribute_by_name(ldb, el->name);
 
+               if (el->num_value == 0) {
+                       ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illegal)",
+                                              el->name, ldb_dn_get_linearized(msg->dn));
+                       return LDB_ERR_CONSTRAINT_VIOLATION;
+               }
+               if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                       if (el->num_values > 1) {
+                               ldb_asprintf_errstring(ldb, "SINGLE-VALUED attribute %s on %s specified more than once",
+                                                      el->name, ldb_dn_get_linearized(msg->dn));
+                               return LDB_ERR_CONSTRAINT_VIOLATION;
+                       }
+               }
+
                /* For each value of the specified attribute name... */
                for (j = 0; j < el->num_values; j++) {
                        struct ldb_val value;
@@ -1125,6 +1138,12 @@ static int lsql_modify(struct lsql_context *ctx)
                char *mod;
                int j;
 
+               if (ldb_attr_cmp(el->name, "distinguishedName") == 0) {
+                       ldb_asprintf_errstring(ldb, "it is not permitted to perform a modify on 'distinguishedName' (use rename instead): %s",
+                                              ldb_dn_get_linearized(msg->dn));
+                       return LDB_ERR_CONSTRAINT_VIOLATION;
+               }
+
                /* Get a case-folded copy of the attribute name */
                attr = ldb_attr_casefold(ctx, el->name);
                if (attr == NULL) {
@@ -1137,6 +1156,21 @@ static int lsql_modify(struct lsql_context *ctx)
 
                case LDB_FLAG_MOD_REPLACE:
 
+                       if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                               if (el->num_values > 1) {
+                                       ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                              el->name, ldb_dn_get_linearized(msg->dn));
+                                       return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                               }
+                       }
+
+                       for (j=0; j<el->num_values; j++) {
+                               if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                       ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+                                       return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                               }
+                       }
+
                        /* remove all attributes before adding the replacements */
                        mod = lsqlite3_tprintf(ctx,
                                                "DELETE FROM ldb_attribute_values "
@@ -1159,6 +1193,21 @@ static int lsql_modify(struct lsql_context *ctx)
                        /* MISSING break is INTENTIONAL */
 
                case LDB_FLAG_MOD_ADD:
+
+                       if (el->num_values == 0) {
+                               ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illigal)",
+                                                      el->name, ldb_dn_get_linearized(msg->dn));
+                               return LDB_ERR_CONSTRAINT_VIOLATION;
+                       }
+
+                       if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                               if (el->num_values > 1) {
+                                       ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                              el->name, ldb_dn_get_linearized(msg->dn));
+                                       return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                               }
+                       }
+
 #warning "We should throw an error if no value is provided!"
                        /* For each value of the specified attribute name... */
                        for (j = 0; j < el->num_values; j++) {

diff --git a/source4/lib/ldb/ldb_tdb/ldb_tdb.c b/source4/lib/ldb/ldb_tdb/ldb_tdb.c
index 55acb6132d8f241de83bbb3bbc931b98e1d8f5fc..63ce6e7aecc2706f6ca400845bfd17b323693591 100644 (file)
--- a/source4/lib/ldb/ldb_tdb/ldb_tdb.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_tdb.c
@@ -1,10 +1,10 @@
 /*
    ldb database library
 
-   Copyright (C) Andrew Tridgell  2004
-   Copyright (C) Stefan Metzmacher  2004
-   Copyright (C) Simo Sorce       2006-2008
-
+   Copyright (C) Andrew Tridgell 2004
+   Copyright (C) Stefan Metzmacher 2004
+   Copyright (C) Simo Sorce 2006-2008
+   Copyright (C) Matthias Dieter Wallnöfer 2009
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -43,6 +43,10 @@
  *  - description: make it possible to use event contexts
  *    date: Jan 2008
  *    Author: Simo Sorce
+ *
+ *  - description: fix up memory leaks and small bugs
+ *    date: Oct 2009
+ *    Author: Matthias Dieter Wallnöfer
  */
 
 #include "ldb_tdb.h"
@@ -169,12 +173,14 @@ static int ltdb_check_special_dn(struct ldb_module *module,
 
        if (! ldb_dn_is_special(msg->dn) ||
            ! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) {
-               return 0;
+               return LDB_SUCCESS;
        }
 
        /* we have @ATTRIBUTES, let's check attributes are fine */
        /* should we check that we deny multivalued attributes ? */
        for (i = 0; i < msg->num_elements; i++) {
+               if (ldb_attr_cmp(msg->elements[i].name, "distinguishedName") == 0) continue;
+
                for (j = 0; j < msg->elements[i].num_values; j++) {
                        if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
                                ldb_set_errstring(ldb, "Invalid attribute value in an @ATTRIBUTES entry");
@@ -183,7 +189,7 @@ static int ltdb_check_special_dn(struct ldb_module *module,
                }
        }
 
-       return 0;
+       return LDB_SUCCESS;
 }
 
 
@@ -201,12 +207,19 @@ static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
                ret = ltdb_reindex(module);
        }
 
+       /* If the modify was to a normal record, or any special except @BASEINFO, update the seq number */
        if (ret == LDB_SUCCESS &&
            !(ldb_dn_is_special(dn) &&
              ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
                ret = ltdb_increase_sequence_number(module);
        }
 
+       /* If the modify was to @OPTIONS, reload the cache */
+       if (ldb_dn_is_special(dn) &&
+           (ldb_dn_check_special(dn, LTDB_OPTIONS)) ) {
+               ret = ltdb_cache_reload(module);
+       }
+
        return ret;
 }
 
@@ -218,10 +231,10 @@ int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flg
        void *data = ldb_module_get_private(module);
        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
        TDB_DATA tdb_key, tdb_data;
-       int ret;
+       int ret = LDB_SUCCESS;
 
        tdb_key = ltdb_key(module, msg->dn);
-       if (!tdb_key.dptr) {
+       if (tdb_key.dptr == NULL) {
                return LDB_ERR_OTHER;
        }
 
@@ -254,7 +267,7 @@ static int ltdb_add_internal(struct ldb_module *module,
                             const struct ldb_message *msg)
 {
        struct ldb_context *ldb = ldb_module_get_ctx(module);
-       int ret, i;
+       int ret = LDB_SUCCESS, i;
 
        ret = ltdb_check_special_dn(module, msg);
        if (ret != LDB_SUCCESS) {
@@ -276,7 +289,7 @@ static int ltdb_add_internal(struct ldb_module *module,
                }
                if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
                        if (el->num_values > 1) {
-                               ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s speicified more than once", 
+                               ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
                                                       el->name, ldb_dn_get_linearized(msg->dn));
                                return LDB_ERR_CONSTRAINT_VIOLATION;
                        }
@@ -284,26 +297,22 @@ static int ltdb_add_internal(struct ldb_module *module,
        }
 
        ret = ltdb_store(module, msg, TDB_INSERT);
-
-       if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
-               ldb_asprintf_errstring(ldb,
-                                       "Entry %s already exists",
-                                       ldb_dn_get_linearized(msg->dn));
+       if (ret != LDB_SUCCESS) {
+               if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+                       ldb_asprintf_errstring(ldb,
+                                              "Entry %s already exists",
+                                              ldb_dn_get_linearized(msg->dn));
+               }
                return ret;
        }
 
-       if (ret == LDB_SUCCESS) {
-               ret = ltdb_index_one(module, msg, 1);
-               if (ret != LDB_SUCCESS) {
-                       return ret;
-               }
-
-               ret = ltdb_modified(module, msg->dn);
-               if (ret != LDB_SUCCESS) {
-                       return ret;
-               }
+       ret = ltdb_index_one(module, msg, 1);
+       if (ret != LDB_SUCCESS) {
+               return ret;
        }
 
+       ret = ltdb_modified(module, msg->dn);
+
        return ret;
 }
 
@@ -314,16 +323,17 @@ static int ltdb_add(struct ltdb_context *ctx)
 {
        struct ldb_module *module = ctx->module;
        struct ldb_request *req = ctx->req;
-       int tret;
+       int ret = LDB_SUCCESS;
 
        ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
-       tret = ltdb_add_internal(module, req->op.add.message);
-       if (tret != LDB_SUCCESS) {
-               return tret;
+       if (ltdb_cache_load(module) != 0) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       return LDB_SUCCESS;
+       ret = ltdb_add_internal(module, req->op.add.message);
+
+       return ret;
 }
 
 /*
@@ -355,7 +365,7 @@ int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn)
 static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
 {
        struct ldb_message *msg;
-       int ret;
+       int ret = LDB_SUCCESS;
 
        msg = talloc(module, struct ldb_message);
        if (msg == NULL) {
@@ -404,7 +414,7 @@ static int ltdb_delete(struct ltdb_context *ctx)
 {
        struct ldb_module *module = ctx->module;
        struct ldb_request *req = ctx->req;
-       int tret;
+       int ret = LDB_SUCCESS;
 
        ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
@@ -412,12 +422,9 @@ static int ltdb_delete(struct ltdb_context *ctx)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       tret = ltdb_delete_internal(module, req->op.del.dn);
-       if (tret != LDB_SUCCESS) {
-               return tret;
-       }
+       ret = ltdb_delete_internal(module, req->op.del.dn);
 
-       return LDB_SUCCESS;
+       return ret;
 }
 
 /*
@@ -453,6 +460,11 @@ static int msg_add_element(struct ldb_context *ldb,
        struct ldb_message_element *e2;
        unsigned int i;
 
+       if (el->num_values == 0) {
+               /* nothing to do here - we don't add empty elements */
+               return 0;
+       }
+
        e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
                              msg->num_elements+1);
        if (!e2) {
@@ -466,21 +478,18 @@ static int msg_add_element(struct ldb_context *ldb,
 
        e2->name = el->name;
        e2->flags = el->flags;
-       e2->values = NULL;
-       if (el->num_values != 0) {
-               e2->values = talloc_array(msg->elements,
-                                         struct ldb_val, el->num_values);
-               if (!e2->values) {
-                       errno = ENOMEM;
-                       return -1;
-               }
+       e2->values = talloc_array(msg->elements,
+                                 struct ldb_val, el->num_values);
+       if (!e2->values) {
+               errno = ENOMEM;
+               return -1;
        }
        for (i=0;i<el->num_values;i++) {
                e2->values[i] = el->values[i];
        }
        e2->num_values = el->num_values;
 
-       msg->num_elements++;
+       ++msg->num_elements;
 
        return 0;
 }
@@ -516,12 +525,17 @@ static int msg_delete_attribute(struct ldb_module *module,
                        msg->num_elements--;
                        i--;
                        msg->elements = talloc_realloc(msg, msg->elements,
-                                                       struct ldb_message_element,
-                                                       msg->num_elements);
+                                                      struct ldb_message_element,
+                                                      msg->num_elements);
+
+                       /* per definition we find in a canonicalised message an
+                          attribute only once. So we are finished here. */
+                       return 0;
                }
        }
 
-       return 0;
+       /* Not found */
+       return -1;
 }
 
 /*
@@ -562,10 +576,14 @@ static int msg_delete_element(struct ldb_module *module,
                                return msg_delete_attribute(module, ldb,
                                                            msg, name);
                        }
+
+                       /* per definition we find in a canonicalised message an
+                          attribute value only once. So we are finished here */
                        return 0;
                }
        }
 
+       /* Not found */
        return -1;
 }
 
@@ -586,7 +604,7 @@ int ltdb_modify_internal(struct ldb_module *module,
        TDB_DATA tdb_key, tdb_data;
        struct ldb_message *msg2;
        unsigned i, j;
-       int ret, idx;
+       int ret = LDB_SUCCESS, idx;
 
        tdb_key = ltdb_key(module, msg->dn);
        if (!tdb_key.dptr) {
@@ -601,160 +619,175 @@ int ltdb_modify_internal(struct ldb_module *module,
 
        msg2 = talloc(tdb_key.dptr, struct ldb_message);
        if (msg2 == NULL) {
-               talloc_free(tdb_key.dptr);
-               return LDB_ERR_OTHER;
+               free(tdb_data.dptr);
+               ret = LDB_ERR_OTHER;
+               goto done;
        }
 
        ret = ltdb_unpack_data(module, &tdb_data, msg2);
+       free(tdb_data.dptr);
        if (ret == -1) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        if (!msg2->dn) {
                msg2->dn = msg->dn;
        }
 
-       for (i=0;i<msg->num_elements;i++) {
-               struct ldb_message_element *el = &msg->elements[i];
-               struct ldb_message_element *el2;
+       for (i=0; i<msg->num_elements; i++) {
+               struct ldb_message_element *el = &msg->elements[i], *el2;
                struct ldb_val *vals;
-               const char *dn;
                const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);
-               switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+               const char *dn;
 
-               case LDB_FLAG_MOD_ADD:
-                       
-                       /* add this element to the message. fail if it
-                          already exists */
-                       idx = find_element(msg2, el->name);
+               if (ldb_attr_cmp(el->name, "distinguishedName") == 0) {
+                       ldb_asprintf_errstring(ldb, "it is not permitted to perform a modify on 'distinguishedName' (use rename instead): %s",
+                                              ldb_dn_get_linearized(msg->dn));
+                       ret = LDB_ERR_CONSTRAINT_VIOLATION;
+                       goto done;
+               }
 
+               switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+               case LDB_FLAG_MOD_ADD:
                        if (el->num_values == 0) {
-                               ldb_asprintf_errstring(ldb, "attribute %s on %s speicified, but with 0 values (illigal)", 
-                                                 el->name, ldb_dn_get_linearized(msg->dn));
-                               return LDB_ERR_CONSTRAINT_VIOLATION;
-                       }
-                       if (idx == -1) {
-                               if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
-                                       if (el->num_values > 1) {
-                                               ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s speicified more than once", 
-                                                              el->name, ldb_dn_get_linearized(msg->dn));
-                                               return LDB_ERR_CONSTRAINT_VIOLATION;
-                                       }
-                               }
-                               if (msg_add_element(ldb, msg2, el) != 0) {
-                                       ret = LDB_ERR_OTHER;
-                                       goto failed;
-                               }
-                               continue;
+                               ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illigal)",
+                                                      el->name, ldb_dn_get_linearized(msg->dn));
+                               ret = LDB_ERR_CONSTRAINT_VIOLATION;
+                               goto done;
                        }
 
-                       /* If this is an add, then if it already
-                        * exists in the object, then we violoate the
-                        * single-value rule */
                        if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
-                               return LDB_ERR_CONSTRAINT_VIOLATION;
+                               if (el->num_values > 1) {
+                                       ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                              el->name, ldb_dn_get_linearized(msg->dn));
+                                       ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                       goto done;
+                               }
                        }
 
-                       el2 = &msg2->elements[idx];
-
-                       /* An attribute with this name already exists,
-                        * add all values if they don't already exist
-                        * (check both the other elements to be added,
-                        * and those already in the db). */
-
-                       for (j=0;j<el->num_values;j++) {
-                               if (ldb_msg_find_val(el2, &el->values[j])) {
-                                       ldb_asprintf_errstring(ldb, "%s: value #%d already exists", el->name, j);
-                                       ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
-                                       goto failed;
+                       /* Checks if element already exists */
+                       idx = find_element(msg2, el->name);
+                       if (idx == -1) {
+                               if (msg_add_element(ldb, msg2, el) != 0) {
+                                       ret = LDB_ERR_OTHER;
+                                       goto done;
                                }
-                               if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
-                                       ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+                       } else {
+                               /* We cannot add another value on a existing one
+                                  if the attribute is single-valued */
+                               if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                                       ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                              el->name, ldb_dn_get_linearized(msg->dn));
                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
-                                       goto failed;
+                                       goto done;
                                }
-                       }
 
-                       vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
-                                               el2->num_values + el->num_values);
+                               el2 = &(msg2->elements[idx]);
 
-                       if (vals == NULL) {
-                               ret = LDB_ERR_OTHER;
-                               goto failed;
-                       }
+                               /* Check that values don't exist yet on multi-
+                                  valued attributes or aren't provided twice */
+                               for (j=0; j<el->num_values; j++) {
+                                       if (ldb_msg_find_val(el2, &el->values[j]) != NULL) {
+                                               ldb_asprintf_errstring(ldb, "%s: value #%d already exists", el->name, j);
+                                               ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                               goto done;
+                                       }
+                                       if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                               ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+                                               ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                               goto done;
+                                       }
+                               }
 
-                       for (j=0;j<el->num_values;j++) {
-                               vals[el2->num_values + j] =
-                                       ldb_val_dup(vals, &el->values[j]);
-                       }
+                               /* Now combine existing and new values to a new
+                                  attribute record */
+                               vals = talloc_realloc(msg2->elements,
+                                       el2->values, struct ldb_val,
+                                       el2->num_values + el->num_values);
+                               if (vals == NULL) {
+                                       ldb_oom(ldb);
+                                       ret = LDB_ERR_OTHER;
+                                       goto done;
+                               }
 
-                       el2->values = vals;
-                       el2->num_values += el->num_values;
+                               for (j=0; j<el->num_values; j++) {
+                                       vals[el2->num_values + j] =
+                                               ldb_val_dup(vals, &el->values[j]);
+                               }
+
+                               el2->values = vals;
+                               el2->num_values += el->num_values;
+                       }
 
                        break;
 
                case LDB_FLAG_MOD_REPLACE:
                        if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
                                if (el->num_values > 1) {
-                                       ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s speicified more than once", 
-                                                              el->name, ldb_dn_get_linearized(msg->dn));
-                                       return LDB_ERR_CONSTRAINT_VIOLATION;
+                                       ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                              el->name, ldb_dn_get_linearized(msg->dn));
+                                       ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                       goto done;
                                }
                        }
-                       /* replace all elements of this attribute name with the elements
-                          listed. The attribute not existing is not an error */
-                       msg_delete_attribute(module, ldb, msg2, el->name);
 
-                       for (j=0;j<el->num_values;j++) {
+                       for (j=0; j<el->num_values; j++) {
                                if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
                                        ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
-                                       goto failed;
+                                       goto done;
                                }
                        }
 
-                       /* add the replacement element, if not empty */
-                       if (el->num_values != 0 &&
-                           msg_add_element(ldb, msg2, el) != 0) {
+                       /* Delete the attribute if it exists in the DB */
+                       msg_delete_attribute(module, ldb, msg2, el->name);
+
+                       /* Recreate it with the new values */
+                       if (msg_add_element(ldb, msg2, el) != 0) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
+
                        break;
 
                case LDB_FLAG_MOD_DELETE:
-
                        dn = ldb_dn_get_linearized(msg->dn);
                        if (dn == NULL) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
 
-                       /* we could be being asked to delete all
-                          values or just some values */
                        if (msg->elements[i].num_values == 0) {
-                               if (msg_delete_attribute(module, ldb, msg2, 
+                               /* Delete the whole attribute */
+                               if (msg_delete_attribute(module, ldb, msg2,
                                                         msg->elements[i].name) != 0) {
-                                       ldb_asprintf_errstring(ldb, "No such attribute: %s for delete on %s", msg->elements[i].name, dn);
-                                       ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
-                                       goto failed;
-                               }
-                               break;
-                       }
-                       for (j=0;j<msg->elements[i].num_values;j++) {
-                               if (msg_delete_element(module,
-                                                      msg2, 
-                                                      msg->elements[i].name,
-                                                      &msg->elements[i].values[j]) != 0) {
-                                       ldb_asprintf_errstring(ldb, "No matching attribute value when deleting attribute: %s on %s", msg->elements[i].name, dn);
+                                       ldb_asprintf_errstring(ldb, "No such attribute: %s for delete on %s",
+                                                              msg->elements[i].name, dn);
                                        ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
-                                       goto failed;
+                                       goto done;
                                }
-                               ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
-                               if (ret != LDB_SUCCESS) {
-                                       goto failed;
+                       } else {
+                               /* Delete specified values from an attribute */
+                               for (j=0; j < msg->elements[i].num_values; j++) {
+                                       if (msg_delete_element(module,
+                                                              msg2,
+                                                              msg->elements[i].name,
+                                                              &msg->elements[i].values[j]) != 0) {
+                                               ldb_asprintf_errstring(ldb, "No matching attribute value when deleting attribute: %s on %s",
+                                                                      msg->elements[i].name, dn);
+                                               ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
+                                               goto done;
+                                       }
+
+                                       ret = ltdb_index_del_value(module, dn,
+                                               &msg->elements[i], j);
+                                       if (ret != LDB_SUCCESS) {
+                                               goto done;
+                                       }
                                }
                        }
+
                        break;
                default:
                        ldb_asprintf_errstring(ldb,
@@ -762,29 +795,22 @@ int ltdb_modify_internal(struct ldb_module *module,
                                msg->elements[i].name,
                                msg->elements[i].flags & LDB_FLAG_MOD_MASK);
                        ret = LDB_ERR_PROTOCOL_ERROR;
-                       goto failed;
+                       goto done;
                }
        }
 
-       /* we've made all the mods
-        * save the modified record back into the database */
        ret = ltdb_store(module, msg2, TDB_MODIFY);
        if (ret != LDB_SUCCESS) {
-               goto failed;
+               goto done;
        }
 
        ret = ltdb_modified(module, msg->dn);
        if (ret != LDB_SUCCESS) {
-               goto failed;
+               goto done;
        }
 
+done:
        talloc_free(tdb_key.dptr);
-       free(tdb_data.dptr);
-       return ret;
-
-failed:
-       talloc_free(tdb_key.dptr);
-       free(tdb_data.dptr);
        return ret;
 }
 
@@ -795,25 +821,22 @@ static int ltdb_modify(struct ltdb_context *ctx)
 {
        struct ldb_module *module = ctx->module;
        struct ldb_request *req = ctx->req;
-       int tret;
-
-       ldb_request_set_state(req, LDB_ASYNC_PENDING);
+       int ret = LDB_SUCCESS;
 
-       tret = ltdb_check_special_dn(module, req->op.mod.message);
-       if (tret != LDB_SUCCESS) {
-               return tret;
+       ret = ltdb_check_special_dn(module, req->op.mod.message);
+       if (ret != LDB_SUCCESS) {
+               return ret;
        }
 
+       ldb_request_set_state(req, LDB_ASYNC_PENDING);
+
        if (ltdb_cache_load(module) != 0) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       tret = ltdb_modify_internal(module, req->op.mod.message);
-       if (tret != LDB_SUCCESS) {
-               return tret;
-       }
+       ret = ltdb_modify_internal(module, req->op.mod.message);
 
-       return LDB_SUCCESS;
+       return ret;
 }
 
 /*
@@ -824,7 +847,7 @@ static int ltdb_rename(struct ltdb_context *ctx)
        struct ldb_module *module = ctx->module;
        struct ldb_request *req = ctx->req;
        struct ldb_message *msg;
-       int tret;
+       int ret = LDB_SUCCESS;
 
        ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
@@ -839,14 +862,14 @@ static int ltdb_rename(struct ltdb_context *ctx)
 
        /* in case any attribute of the message was indexed, we need
           to fetch the old record */
-       tret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
-       if (tret != LDB_SUCCESS) {
+       ret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
+       if (ret != LDB_SUCCESS) {
                /* not finding the old record is an error */
-               return tret;
+               return ret;
        }
 
        msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
-       if (!msg->dn) {
+       if (msg->dn == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -854,17 +877,14 @@ static int ltdb_rename(struct ltdb_context *ctx)
         * unique indexes. We rely on the transaction to make this
         * atomic
         */
-       tret = ltdb_delete_internal(module, req->op.rename.olddn);
-       if (tret != LDB_SUCCESS) {
-               return tret;
+       ret = ltdb_delete_internal(module, req->op.rename.olddn);
+       if (ret != LDB_SUCCESS) {
+               return ret;
        }
 
-       tret = ltdb_add_internal(module, msg);
-       if (tret != LDB_SUCCESS) {
-               return tret;
-       }
+       ret = ltdb_add_internal(module, msg);
 
-       return LDB_SUCCESS;
+       return ret;
 }
 
 static int ltdb_start_trans(struct ldb_module *module)
@@ -964,7 +984,7 @@ static int ltdb_sequence_number(struct ltdb_context *ctx,
        struct ldb_message *msg = NULL;
        struct ldb_dn *dn;
        const char *date;
-       int ret;
+       int ret = LDB_SUCCESS;
 
        ldb = ldb_module_get_ctx(module);
 
@@ -1031,8 +1051,6 @@ static int ltdb_sequence_number(struct ltdb_context *ctx,
        (*ext)->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
        (*ext)->data = talloc_steal(*ext, res);
 
-       ret = LDB_SUCCESS;
-
 done:
        talloc_free(tmp_ctx);
        ltdb_unlock_read(module);
@@ -1217,7 +1235,7 @@ static int ltdb_handle_request(struct ldb_module *module,
 
        ac = talloc_zero(ldb, struct ltdb_context);
        if (ac == NULL) {
-               ldb_set_errstring(ldb, "Out of Memory");
+               ldb_oom(ldb);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 

diff --git a/source4/lib/ldb/modules/asq.c b/source4/lib/ldb/modules/asq.c
index 0819f7f5597ae1e2211c2f361d432cb571bb3cce..491868301c46b945465d88b037b36abbfbd01cea 100644 (file)
--- a/source4/lib/ldb/modules/asq.c
+++ b/source4/lib/ldb/modules/asq.c
@@ -237,7 +237,7 @@ static int asq_build_first_request(struct asq_context *ac, struct ldb_request **
                                        ac, asq_base_callback,
                                        ac->req);
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        return LDB_SUCCESS;
@@ -292,7 +292,7 @@ static int asq_build_multiple_requests(struct asq_context *ac, bool *terminated)
                                                ac, asq_reqs_callback,
                                                ac->req);
                if (ret != LDB_SUCCESS) {
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       return ret;
                }
 
                /* remove the ASQ control itself */

diff --git a/source4/lib/ldb/modules/paged_results.c b/source4/lib/ldb/modules/paged_results.c
index b712f84872154327aeda6bd5a8749fd80d0144d6..774109ff06d6fa22aa2922939e22e41f1510475c 100644 (file)
--- a/source4/lib/ldb/modules/paged_results.c
+++ b/source4/lib/ldb/modules/paged_results.c
@@ -347,6 +347,9 @@ static int paged_search(struct ldb_module *module, struct ldb_request *req)
                                                ac,
                                                paged_search_callback,
                                                req);
+               if (ret != LDB_SUCCESS) {
+                       return ret;
+               }
 
                /* save it locally and remove it from the list */
                /* we do not need to replace them later as we

diff --git a/source4/lib/ldb/modules/rdn_name.c b/source4/lib/ldb/modules/rdn_name.c
index 8b54f52b5ecac133d8ee4dbba754a082ff0f40e7..d018c4f20592ceafdce81a8efb9fb7e3cf23e7e6 100644 (file)
--- a/source4/lib/ldb/modules/rdn_name.c
+++ b/source4/lib/ldb/modules/rdn_name.c
@@ -1,7 +1,7 @@
 /* 
    ldb database library
 
-   Copyright (C) Andrew Bartlett 2005
+   Copyright (C) Andrew Bartlett 2005-2009
    Copyright (C) Simo Sorce 2006-2008
 
      ** NOTE! The following LGPL license applies to the ldb
@@ -40,7 +40,6 @@
 #include "ldb_module.h"
 
 struct rename_context {
-
        struct ldb_module *module;
        struct ldb_request *req;
 
@@ -120,7 +119,6 @@ static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
 
        rdn_name = ldb_dn_get_rdn_name(msg->dn);
        if (rdn_name == NULL) {
-               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
        
@@ -132,7 +130,6 @@ static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
        }
 
        if (ldb_msg_add_value(msg, "name", &rdn_val, NULL) != 0) {
-               talloc_free(ac);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -140,7 +137,6 @@ static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
 
        if (!attribute) {
                if (ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL) != 0) {
-                       talloc_free(ac);
                        return LDB_ERR_OPERATIONS_ERROR;
                }
        } else {
@@ -156,16 +152,17 @@ static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
                        }
                }
                if (i == attribute->num_values) {
-                       char *rdn_errstring = talloc_asprintf(ac, "RDN mismatch on %s: %s (%.*s) should match one of:", 
-                                                         ldb_dn_get_linearized(msg->dn), rdn_name, 
-                                                         (int)rdn_val.length, (const char *)rdn_val.data);
+                       char *rdn_errstring = talloc_asprintf(ac,
+                               "RDN mismatch on %s: %s (%.*s) should match one of:", 
+                               ldb_dn_get_linearized(msg->dn), rdn_name, 
+                               (int)rdn_val.length, (const char *)rdn_val.data);
                        for (i = 0; i < attribute->num_values; i++) {
-                               rdn_errstring = talloc_asprintf_append(rdn_errstring, " (%.*s)",
-                                                                      (int)attribute->values[i].length, 
-                                                                      (const char *)attribute->values[i].data);
+                               rdn_errstring = talloc_asprintf_append(
+                                       rdn_errstring, " (%.*s)",
+                                       (int)attribute->values[i].length, 
+                                       (const char *)attribute->values[i].data);
                        }
-                       ldb_debug_set(ldb, LDB_DEBUG_FATAL, "%s", rdn_errstring);
-                       talloc_free(ac);
+                       ldb_set_errstring(ldb, rdn_errstring);
                        /* Match AD's error here */
                        return LDB_ERR_INVALID_DN_SYNTAX;
                }
@@ -278,12 +275,12 @@ static int rdn_rename_callback(struct ldb_request *req, struct ldb_reply *ares)
        }
        talloc_steal(mod_req, msg);
 
-       /* do the mod call */
-       return ldb_request(ldb, mod_req);
+       /* go on with the call chain */
+       return ldb_next_request(ac->module, mod_req);
 
 error:
        return ldb_module_done(ac->req, NULL, NULL,
-                                               LDB_ERR_OPERATIONS_ERROR);
+                                                LDB_ERR_OPERATIONS_ERROR);
 }
 
 static int rdn_name_rename(struct ldb_module *module, struct ldb_request *req)
@@ -320,15 +317,44 @@ static int rdn_name_rename(struct ldb_module *module, struct ldb_request *req)
                                   req);
 
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        /* rename first, modify "name" if rename is ok */
        return ldb_next_request(module, down_req);
 }
 
+static int rdn_name_modify(struct ldb_module *module, struct ldb_request *req)
+{
+       struct ldb_context *ldb;
+
+       ldb = ldb_module_get_ctx(module);
+       ldb_debug(ldb, LDB_DEBUG_TRACE, "rdn_name_rename");
+
+       /* do not manipulate our control entries */
+       if (ldb_dn_is_special(req->op.mod.message->dn)) {
+               return ldb_next_request(module, req);
+       }
+
+       if (ldb_msg_find_element(req->op.mod.message, "name")) {
+               ldb_asprintf_errstring(ldb, "Modify of 'name' on %s not permitted, must use 'rename' operation instead",
+                                      ldb_dn_get_linearized(req->op.mod.message->dn));
+               return LDB_ERR_NOT_ALLOWED_ON_RDN;
+       }
+
+       if (ldb_msg_find_element(req->op.mod.message, ldb_dn_get_rdn_name(req->op.mod.message->dn))) {
+               ldb_asprintf_errstring(ldb, "Modify of RDN '%s' on %s not permitted, must use 'rename' operation instead",
+                                      ldb_dn_get_rdn_name(req->op.mod.message->dn), ldb_dn_get_linearized(req->op.mod.message->dn));
+               return LDB_ERR_NOT_ALLOWED_ON_RDN;
+       }
+
+       /* All OK, they kept their fingers out of the special attributes */
+       return ldb_next_request(module, req);
+}
+
 const struct ldb_module_ops ldb_rdn_name_module_ops = {
        .name              = "rdn_name",
        .add               = rdn_name_add,
-       .rename            = rdn_name_rename,
+       .modify            = rdn_name_modify,
+       .rename            = rdn_name_rename
 };

diff --git a/source4/lib/ldb/modules/sort.c b/source4/lib/ldb/modules/sort.c
index b4ea017b3269947e70c11ce756f049ba1d933ea7..f0aea770184497822c88437a273f1695d127968a 100644 (file)
--- a/source4/lib/ldb/modules/sort.c
+++ b/source4/lib/ldb/modules/sort.c
@@ -315,7 +315,7 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
                                        server_sort_search_callback,
                                        req);
        if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ret;
        }
 
        /* save it locally and remove it from the list */

diff --git a/source4/lib/ldb/pyldb.c b/source4/lib/ldb/pyldb.c
index 1ba5109f2fde038464627f8a153bd3ed97d835d6..1d47d6ff1f419a78a3ec75cdeb57939ff2726ff3 100644 (file)
--- a/source4/lib/ldb/pyldb.c
+++ b/source4/lib/ldb/pyldb.c
@@ -656,6 +656,7 @@ static PyObject *py_ldb_modify(PyLdbObject *self, PyObject *args)
        Py_RETURN_NONE;
 }
 
+
 static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args)
 {
        PyObject *py_msg;
@@ -956,8 +957,10 @@ static PyObject *py_ldb_msg_diff(PyLdbObject *self, PyObject *args)
        }
 
        diff = ldb_msg_diff(PyLdb_AsLdbContext(self), PyLdbMessage_AsMessage(py_msg_old), PyLdbMessage_AsMessage(py_msg_new));
-       if (diff == NULL) 
+       if (!diff) {
+               PyErr_SetString(PyExc_RuntimeError, "Failed to generate the Ldb Message diff");
                return NULL;
+       }
 
        py_ret = PyLdbMessage_FromMessage(diff);
 

diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py
index 5b2d380f11a05a049e2eebf88bfbba25e36b0005..118fb87c8425e0acb219effc12dbe6da940e9e8d 100755 (executable)
--- a/source4/lib/ldb/tests/python/ldap.py
+++ b/source4/lib/ldb/tests/python/ldap.py
@@ -19,8 +19,29 @@ from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
 from ldb import ERR_NO_SUCH_OBJECT, ERR_ATTRIBUTE_OR_VALUE_EXISTS
 from ldb import ERR_ENTRY_ALREADY_EXISTS, ERR_UNWILLING_TO_PERFORM
 from ldb import ERR_NOT_ALLOWED_ON_NON_LEAF, ERR_OTHER, ERR_INVALID_DN_SYNTAX
-from ldb import Message, MessageElement, Dn, FLAG_MOD_REPLACE
+from ldb import ERR_NO_SUCH_ATTRIBUTE, ERR_INSUFFICIENT_ACCESS_RIGHTS
+from ldb import ERR_OBJECT_CLASS_VIOLATION, ERR_NOT_ALLOWED_ON_RDN
+from ldb import ERR_NAMING_VIOLATION, ERR_CONSTRAINT_VIOLATION
+from ldb import Message, MessageElement, Dn
+from ldb import FLAG_MOD_ADD, FLAG_MOD_REPLACE, FLAG_MOD_DELETE
 from samba import Ldb, param, dom_sid_to_rid
+from samba import UF_NORMAL_ACCOUNT, UF_TEMP_DUPLICATE_ACCOUNT
+from samba import UF_SERVER_TRUST_ACCOUNT, UF_WORKSTATION_TRUST_ACCOUNT
+from samba import UF_INTERDOMAIN_TRUST_ACCOUNT
+from samba import UF_PASSWD_NOTREQD, UF_ACCOUNTDISABLE
+from samba import GTYPE_SECURITY_BUILTIN_LOCAL_GROUP
+from samba import GTYPE_SECURITY_GLOBAL_GROUP, GTYPE_SECURITY_DOMAIN_LOCAL_GROUP
+from samba import GTYPE_SECURITY_UNIVERSAL_GROUP
+from samba import GTYPE_DISTRIBUTION_GLOBAL_GROUP
+from samba import GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP
+from samba import GTYPE_DISTRIBUTION_UNIVERSAL_GROUP
+from samba import ATYPE_NORMAL_ACCOUNT, ATYPE_WORKSTATION_TRUST
+from samba import ATYPE_SECURITY_GLOBAL_GROUP, ATYPE_SECURITY_LOCAL_GROUP
+from samba import ATYPE_SECURITY_UNIVERSAL_GROUP
+from samba import ATYPE_DISTRIBUTION_GLOBAL_GROUP
+from samba import ATYPE_DISTRIBUTION_LOCAL_GROUP
+from samba import ATYPE_DISTRIBUTION_UNIVERSAL_GROUP
+
 from subunit import SubunitTestRunner
 import unittest
 
@@ -83,30 +104,435 @@ class BasicTests(unittest.TestCase):
         print "baseDN: %s\n" % self.base_dn
 
         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
-        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
         self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
         self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
-        self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà ,cn=users," + self.base_dn)
-        self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà ,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
         self.delete_force(self.ldb, "cn=parentguidtest,cn=users," + self.base_dn)
         self.delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
         self.delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
+        self.delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
+
+    def test_system_only(self):
+        """Test systemOnly objects"""
+        print "Test systemOnly objects"""
 
-    def test_group_add_invalid_member(self):
-        """Testing group add with invalid member"""
         try:
             self.ldb.add({
-                "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn,
-                "objectclass": "group",
-                "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
+                "dn": "cn=ldaptestobject," + self.base_dn,
+                "objectclass": "configuration"})
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+
+        self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
+
+    def test_invalid_parent(self):
+        """Test adding an object with invalid parent"""
+        print "Test adding an object with invalid parent"""
+
+        try:
+            self.ldb.add({
+                "dn": "cn=ldaptestgroup,cn=thisdoesnotexist123,"
+                   + self.base_dn,
+                "objectclass": "group"})
             self.fail()
         except LdbError, (num, _):
             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
+          + self.base_dn)
+
+        try:
+            self.ldb.add({
+                "dn": "ou=testou,cn=users," + self.base_dn,
+                "objectclass": "organizationalUnit"})
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NAMING_VIOLATION)
+
+        self.delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
+
+    def test_invalid_attribute(self):
+        """Test adding invalid attributes (not in schema)"""
+        print "Test adding invalid attributes (not in schema)"""
+
+        try:
+            self.ldb.add({
+                "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+                "objectclass": "group",
+                "thisdoesnotexist": "x"})
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+
+        self.ldb.add({
+             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+             "objectclass": "group"})
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["thisdoesnotexist"] = MessageElement("x", FLAG_MOD_REPLACE,
+          "thisdoesnotexist")
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_single_valued_attributes(self):
+        """Test single-valued attributes"""
+        print "Test single-valued attributes"""
+
+        try:
+            self.ldb.add({
+                "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+                "objectclass": "group",
+                "sAMAccountName": ["nam1", "nam2"]})
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+        self.ldb.add({
+             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+             "objectclass": "group"})
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["sAMAccountName"] = MessageElement(["nam1","nam2"], FLAG_MOD_REPLACE,
+          "sAMAccountName")
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["sAMAccountName"] = MessageElement("testgroupXX", FLAG_MOD_REPLACE,
+          "sAMAccountName")
+        ldb.modify(m)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["sAMAccountName"] = MessageElement("testgroupXX2", FLAG_MOD_ADD,
+          "sAMAccountName")
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_multi_valued_attributes(self):
+        """Test multi-valued attributes"""
+        print "Test multi-valued attributes"""
+
+# TODO: In this test I added some special tests where I got very unusual
+# results back from a real AD. s4 doesn't match them and I've no idea how to
+# implement those error cases (maybe there exists a special trigger for
+# "description" attributes which handle them)
+
+        self.ldb.add({
+            "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+            "description": "desc2",
+            "objectclass": "group",
+            "description": "desc1"})
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+        self.ldb.add({
+            "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+            "objectclass": "group",
+            "description": ["desc1", "desc2"]})
+
+#        m = Message()
+#        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+#        m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_REPLACE,
+#          "description")
+#        try:
+#            ldb.modify(m)
+#            self.fail()
+#        except LdbError, (num, _):
+#            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement("desc1", FLAG_MOD_REPLACE,
+          "description")
+        ldb.modify(m)
+
+#        m = Message()
+#        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+#        m["description"] = MessageElement("desc3", FLAG_MOD_ADD,
+#          "description")
+#        try:
+#            ldb.modify(m)
+#            self.fail()
+#        except LdbError, (num, _):
+#            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_DELETE,
+          "description")
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement("desc1", FLAG_MOD_DELETE,
+          "description")
+        ldb.modify(m)
+
+#        m = Message()
+#        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+#        m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_REPLACE,
+#          "description")
+#        try:
+#            ldb.modify(m)
+#            self.fail()
+#        except LdbError, (num, _):
+#            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+#        m = Message()
+#        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+#        m["description"] = MessageElement(["desc3", "desc4"], FLAG_MOD_ADD,
+#          "description")
+#        try:
+#            ldb.modify(m)
+#            self.fail()
+#        except LdbError, (num, _):
+#            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement("desc3", FLAG_MOD_ADD,
+          "description")
+        ldb.modify(m)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_empty_messages(self):
+        """Test empty messages"""
+        print "Test empty messages"""
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+        try:
+            ldb.add(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_empty_attributes(self):
+        """Test empty attributes"""
+        print "Test empty attributes"""
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["objectClass"] = MessageElement("group", FLAG_MOD_ADD, "objectClass")
+        m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
+
+        try:
+            ldb.add(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+        self.ldb.add({
+            "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+            "objectclass": "group"})
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement([], FLAG_MOD_REPLACE, "description")
+        ldb.modify(m)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["description"] = MessageElement([], FLAG_MOD_DELETE, "description")
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_distinguished_name(self):
+        """Tests the 'distinguishedName' attribute"""
+        print "Tests the 'distinguishedName' attribute"""
+
+        self.ldb.add({
+             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+             "objectclass": "group"})
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["distinguishedName"] = MessageElement(
+          "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
+          "distinguishedName")
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["distinguishedName"] = MessageElement(
+          "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
+          "distinguishedName")
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["distinguishedName"] = MessageElement(
+          "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
+          "distinguishedName")
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_rdn_name(self):
+        """Tests the RDN"""
+        print "Tests the RDN"""
+
+        try:
+            self.ldb.add({
+                 "dn": "description=xyz,cn=users," + self.base_dn,
+                 "objectclass": "group"})
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NAMING_VIOLATION)
+ 
+        self.delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
+
+        self.ldb.add({
+             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
+             "objectclass": "group"})
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["name"] = MessageElement("cn=ldaptestuser", FLAG_MOD_REPLACE,
+          "name")
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
+
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["cn"] = MessageElement("ldaptestuser",
+          FLAG_MOD_REPLACE, "cn")
+
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
+
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+
+    def test_largeRDN(self):
+        """Testing large rDN (limit 64 characters)"""
+        rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012";
+        self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
+        ldif = """
+dn: %s,%s""" % (rdn,self.base_dn) + """
+objectClass: container
+"""
+        self.ldb.add_ldif(ldif)
+        self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
+
+        rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120";
+        self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
+        try:
+            ldif = """
+dn: %s,%s""" % (rdn,self.base_dn) + """
+objectClass: container
+"""
+            self.ldb.add_ldif(ldif)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+        self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
+
+    def test_rename(self):
+        """Tests the rename operation"""
+        print "Tests the rename operations"""
+
+        self.ldb.add({
+             "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
+             "objectclass": ["user", "person"] })
+
+        ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
+        ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
+        ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn)
+        try:
+            ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, ",cn=users," + self.base_dn)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+
+        self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
+
     def test_parentGUID(self):
         """Test parentGUID behaviour"""
         print "Testing parentGUID behaviour\n"
 
+        # TODO: This seems to fail on Windows Server. Hidden attribute?
+
         self.ldb.add({
             "dn": "cn=parentguidtest,cn=users," + self.base_dn,
             "objectclass":"user",
@@ -117,7 +543,6 @@ class BasicTests(unittest.TestCase):
                           attrs=["objectGUID"]);
         self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"]);
 
-        """Test parentGUID behaviour"""
         print "Testing parentGUID behaviour on rename\n"
 
         self.ldb.add({
@@ -131,12 +556,13 @@ class BasicTests(unittest.TestCase):
                           scope=SCOPE_BASE,
                           attrs=["parentGUID"]);
         self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"]);
-        ldb.delete("cn=parentguidtest,cn=testotherusers," + self.base_dn)
-        ldb.delete("cn=testotherusers," + self.base_dn)
 
-    def test_groupType(self):
-        """Test groupType behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
-        print "Testing groupType behaviour\n"
+        self.delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
+
+    def test_groupType_int32(self):
+        """Test groupType (int32) behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
+        print "Testing groupType (int32) behaviour\n"
 
         res1 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
                           attrs=["groupType"], expression="groupType=2147483653");
@@ -150,13 +576,9 @@ class BasicTests(unittest.TestCase):
 
         self.assertEquals(res1[0]["groupType"][0], "-2147483643")
 
-    def test_primary_group(self):
-        """This tests the primary group behaviour (setting, changing) of a user account"""
-        print "Testing primary group behaviour\n"
-
-        ldb.add({
-            "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
-            "objectclass": ["user", "person"]})
+    def test_groups(self):
+        """This tests the group behaviour (setting, changing) of a user account"""
+        print "Testing group behaviour\n"
 
         ldb.add({
             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
@@ -178,6 +600,33 @@ class BasicTests(unittest.TestCase):
         group_rid_2 = dom_sid_to_rid(ldb.schema_format_value("objectSID",
           res1[0]["objectSID"][0]))
 
+        # Try to create a user with an invalid primary group
+       try:
+            ldb.add({
+                "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
+                "objectclass": ["user", "person"],
+                "primaryGroupID": "0"})
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+        self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
+
+        # Try to Create a user with a valid primary group
+# TODO Some more investigation needed here
+#        try:
+#            ldb.add({
+#                "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
+#                "objectclass": ["user", "person"],
+#                "primaryGroupID": str(group_rid_1)})
+#            self.fail()
+#        except LdbError, (num, _):
+#            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+#        self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
+
+        ldb.add({
+            "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
+            "objectclass": ["user", "person"]})
+
         # Try to add invalid primary group
         m = Message()
         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
@@ -231,6 +680,18 @@ class BasicTests(unittest.TestCase):
         except LdbError, (num, _):
             self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
 
+        # Try to add invalid member to group 1 - should be denied
+        m = Message()
+        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        m["member"] = MessageElement(
+          "cn=ldaptestuser3,cn=users," + self.base_dn,
+          FLAG_MOD_ADD, "member")
+        try:
+            ldb.modify(m)
+            self.fail()
+        except LdbError, (num, _):
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+
         # Make group 2 secondary
         m = Message()
         m.dn = Dn(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
@@ -302,7 +763,7 @@ class BasicTests(unittest.TestCase):
        rid = dom_sid_to_rid(ldb.schema_format_value("objectSID", res1[0]["objectSID"][0]))
         self.assertEquals(primary_group_token, rid)
 
-# Has to wait until we support read-only generated attributes correctly
+# TODO Has to wait until we support read-only generated attributes correctly
 #        m = Message()
 #        m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 #        m["primaryGroupToken"] = "100"
@@ -319,8 +780,6 @@ class BasicTests(unittest.TestCase):
 
         print "Testing user add"
 
-        self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
-
         ldb.add({
             "dn": "cn=ldaptestuser,cn=uSers," + self.base_dn,
             "objectclass": ["user", "person"],
@@ -328,27 +787,22 @@ class BasicTests(unittest.TestCase):
             "givenname": "ldap",
             "sn": "testy"})
 
-        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
-
         ldb.add({
             "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn,
             "objectclass": "group",
             "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
 
-        self.delete_force(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
         ldb.add({
             "dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn,
             "objectclass": "computer",
             "cN": "LDAPtestCOMPUTER"})
 
-        self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
         ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + self.base_dn,
             "objectClass": "computer",
             "cn": "LDAPtest2COMPUTER",
-            "userAccountControl": "4096",
+            "userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT),
             "displayname": "ldap testy"})
 
-        self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
         try:
             ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
                      "objectClass": "computer",
@@ -358,50 +812,16 @@ class BasicTests(unittest.TestCase):
         except LdbError, (num, _):
             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
 
-        self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
         try:
             ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
                      "objectClass": "computer",
                      "cn": "ldaptestcomputer3",
-                     "sAMAccountType": "805306368"
+                     "sAMAccountType": str(ATYPE_NORMAL_ACCOUNT)
                 })
             self.fail()
         except LdbError, (num, _):
             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 
-        self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
-        try:
-            ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
-                     "objectClass": "computer",
-                     "cn": "ldaptestcomputer3",
-                     "userAccountControl": "0"
-                })
-            self.fail()
-        except LdbError, (num, _):
-            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
-
-        self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn)
-        try:
-            ldb.add({"dn": "cn=ldaptestuser7,cn=users," + self.base_dn,
-                     "objectClass": "user",
-                     "cn": "LDAPtestuser7",
-                     "userAccountControl": "0"
-                })
-            self.fail()
-        except LdbError, (num, _):
-            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
-
-        self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn)
-
-        ldb.add({"dn": "cn=ldaptestuser7,cn=users," + self.base_dn,
-                 "objectClass": "user",
-                 "cn": "LDAPtestuser7",
-                 "userAccountControl": "2"
-                 })
-
-        self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn)
-
-        self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
         ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
                  "objectClass": "computer",
                  "cn": "LDAPtestCOMPUTER3"
@@ -423,8 +843,8 @@ class BasicTests(unittest.TestCase):
         self.assertTrue("whenCreated" in res[0])
        self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn));
        self.assertEquals(int(res[0]["primaryGroupID"][0]), 513);
-       self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368);
-       self.assertEquals(int(res[0]["userAccountControl"][0]), 546);
+       self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT);
+       self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE);
 
         self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
 
@@ -642,29 +1062,6 @@ servicePrincipalName: host/ldaptest2computer29
 #        res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
 #        self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
 
-        print "Testing Group Modifies"
-        ldb.modify_ldif("""
-dn: cn=ldaptestgroup,cn=users,""" + self.base_dn + """
-changetype: modify
-add: member
-member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
-member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """
-""")
-
-        self.delete_force(ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
-
-        print "Testing adding non-existent user to a group"
-        try:
-            ldb.modify_ldif("""
-dn: cn=ldaptestgroup,cn=users,""" + self.base_dn + """
-changetype: modify
-add: member
-member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
-""")
-            self.fail()
-        except LdbError, (num, _):
-            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
-
         print "Testing Renames"
 
         attrs = ["objectGUID", "objectSid"]
@@ -672,12 +1069,8 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
         res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
         self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
 
-        #Check rename works with extended/alternate DN forms
-        ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestuser3,cn=users," + self.base_dn)
-
-        ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
-
-        ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn)
+        # Check rename works with extended/alternate DN forms
+        ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestUSER3,cn=users," + self.base_dn)
 
         print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
         res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
@@ -737,7 +1130,7 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
         # rename back
         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
 
-        # ensure we cannnot rename it twice
+        # ensure we cannot rename it twice
         try:
             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn,
                        "cn=ldaptestuser2,cn=users," + self.base_dn)
@@ -750,7 +1143,7 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
                       "objectClass": ["person", "user"],
                       "cn": "LDAPtestUSER3"})
 
-        # ensure we now cannnot rename
+        # ensure we now cannot rename
         try:
             ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
             self.fail()
@@ -770,12 +1163,11 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
 
         ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn)
 
-        print "Testing subtree Renames"
+        print "Testing subtree renames"
 
         ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn,
                  "objectClass": "container"})
 
-        self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
         ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + self.base_dn,
                  "objectClass": ["person", "user"],
                  "cn": "LDAPtestUSER4"})
@@ -785,6 +1177,8 @@ dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
 changetype: modify
 add: member
 member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
+member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """
+member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
 """)
 
         print "Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
@@ -864,11 +1258,9 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         print "Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
         ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
 
-        self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà ,cn=users," + self.base_dn)
-        ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + self.base_dn, "objectClass": "user"})
+        ldb.add({"dn": "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
 
-        self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà ,cn=users," + self.base_dn)
-        ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà ,cn=users," + self.base_dn, "objectClass": "user"})
+        ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
 
         print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
         res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
@@ -881,8 +1273,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         self.assertTrue("objectGUID" in res[0])
         self.assertTrue("whenCreated" in res[0])
         self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn))
-        self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368)
-        self.assertEquals(int(res[0]["userAccountControl"][0]), 546)
+        self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
+        self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
         self.assertEquals(len(res[0]["memberOf"]), 1)
 
@@ -926,8 +1318,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         self.assertTrue("whenCreated" in res[0])
         self.assertEquals(str(res[0]["objectCategory"]), ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn))
         self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
-        self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368)
-        self.assertEquals(int(res[0]["userAccountControl"][0]), 546)
+        self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
+        self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
         self.assertEquals(len(res[0]["memberOf"]), 1)
 
@@ -988,8 +1380,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         self.assertTrue("objectGUID" in res[0])
         self.assertTrue("whenCreated" in res[0])
         self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)
-        self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306369)
-        self.assertEquals(int(res[0]["userAccountControl"][0]), 4096)
+        self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
+        self.assertEquals(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
 
         ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
 
@@ -1115,7 +1507,9 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
         self.assertTrue("member" not in res[0])
 
         print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
-        res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+# TODO UTF8 users don't seem to work fully anymore
+#        res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+        res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
@@ -1136,9 +1530,9 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
         ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn))
 
         print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
-        res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
-
-        #FIXME: self.assert len(res) == 1, "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
+# TODO UTF8 users don't seem to work fully anymore
+#        res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+#        self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
 
         print "Testing that we can't get at the configuration DN from the main search base"
         res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
@@ -1212,6 +1606,21 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
         res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
         self.assertTrue(len(res) > 0)
 
+        self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
+
     def test_security_descriptor_add(self):
         """ Testing ldb.add_ldif() for nTSecurityDescriptor """
         user_name = "testdescriptoruser1"
@@ -1463,6 +1872,7 @@ class SchemaTests(unittest.TestCase):
         self.assertFalse("objectClasses" in res[0])
         self.assertFalse("attributeTypes" in res[0])
 
+
     def test_schemaUpdateNow(self):
         """Testing schemaUpdateNow"""
         class_name = "test-class" + time.strftime("%s", time.gmtime())

diff --git a/source4/lib/socket/socket.h b/source4/lib/socket/socket.h
index 0f469e5ceb992e59f3e9d019679e1c82629617e7..02872457b589c96d4943f8880a3971364bd7e003 100644 (file)
--- a/source4/lib/socket/socket.h
+++ b/source4/lib/socket/socket.h
@@ -206,7 +206,7 @@ NTSTATUS socket_connect_multi(TALLOC_CTX *mem_ctx, const char *server_address,
                              struct socket_context **result,
                              uint16_t *port);
 void set_socket_options(int fd, const char *options);
-void socket_set_flags(struct socket_context *socket, unsigned flags);
+void socket_set_flags(struct socket_context *sock, unsigned flags);
 
 void socket_tevent_fd_close_fn(struct tevent_context *ev,
                               struct tevent_fd *fde,

diff --git a/source4/lib/tls/tls.c b/source4/lib/tls/tls.c
index ba2e9e431b3b94a4a9d286b1f4524faac25d4fad..470b555aeeaf6633136d1d9a9f80a4f6a9909703 100644 (file)
--- a/source4/lib/tls/tls.c
+++ b/source4/lib/tls/tls.c
@@ -377,7 +377,8 @@ struct tls_params *tls_initialise(TALLOC_CTX *mem_ctx, struct loadparm_context *
 
        if (!file_exist(cafile)) {
                char *hostname = talloc_asprintf(mem_ctx, "%s.%s",
-                                                lp_netbios_name(lp_ctx), lp_realm(lp_ctx));
+                                                lp_netbios_name(lp_ctx),
+                                                lp_dnsdomain(lp_ctx));
                if (hostname == NULL) {
                        goto init_failed;
                }

diff --git a/source4/lib/wmi/tools/wmic.c b/source4/lib/wmi/tools/wmic.c
index d37e22d44f77269df889240c8d3e67855fcbdf93..bbfe5ed3341a1c7c582baa40724ec7ce41cf2b28 100644 (file)
--- a/source4/lib/wmi/tools/wmic.c
+++ b/source4/lib/wmi/tools/wmic.c
@@ -35,91 +35,61 @@
 #include "lib/wmi/wmi.h"
 
 struct program_args {
-       char *hostname;
-       char *query;
-       char *ns;
+    char *hostname;
+    char *query;
+    char *ns;
 };
 
 static void parse_args(int argc, char *argv[], struct program_args *pmyargs)
 {
-       poptContext pc;
-       int opt, i;
-
-       int argc_new;
-       char **argv_new;
-
-       struct poptOption long_options[] = {
-               POPT_AUTOHELP
-               POPT_COMMON_SAMBA
-               POPT_COMMON_CONNECTION
-               POPT_COMMON_CREDENTIALS
-               POPT_COMMON_VERSION
-               {"namespace", 0, POPT_ARG_STRING, &pmyargs->ns, 0,
-                "WMI namespace, default to root\\cimv2", 0},
-               POPT_TABLEEND
-       };
-
-       pc = poptGetContext("wmi", argc, (const char **) argv,
-               long_options, POPT_CONTEXT_KEEP_FIRST);
-
-       poptSetOtherOptionHelp(pc, "//host query\n\nExample: wmic -U [domain/]adminuser%password //host \"select * from Win32_ComputerSystem\"");
-
-       while ((opt = poptGetNextOpt(pc)) != -1) {
-               poptPrintUsage(pc, stdout, 0);
-               poptFreeContext(pc);
-               exit(1);
-       }
-
-       argv_new = discard_const_p(char *, poptGetArgs(pc));
-
-       argc_new = argc;
-       for (i = 0; i < argc; i++) {
-               if (argv_new[i] == NULL) {
-                       argc_new = i;
-                       break;
-               }
-       }
-
-       if (argc_new != 3 || argv_new[1][0] != '/'
-                       || argv_new[1][1] != '/') {
-               poptPrintUsage(pc, stdout, 0);
-               poptFreeContext(pc);
-               exit(1);
-       }
-
-       pmyargs->hostname = argv_new[1] + 2;
-       pmyargs->query = argv_new[2];
+    poptContext pc;
+    int opt, i;
+
+    int argc_new;
+    char **argv_new;
+
+    struct poptOption long_options[] = {
+       POPT_AUTOHELP
+       POPT_COMMON_SAMBA
+       POPT_COMMON_CONNECTION
+       POPT_COMMON_CREDENTIALS
+       POPT_COMMON_VERSION
+       {"namespace", 0, POPT_ARG_STRING, &pmyargs->ns, 0,
+        "WMI namespace, default to root\\cimv2", 0},
+       POPT_TABLEEND
+    };
+
+    pc = poptGetContext("wmi", argc, (const char **) argv,
+               long_options, POPT_CONTEXT_KEEP_FIRST);
+
+    poptSetOtherOptionHelp(pc, "//host query\n\nExample: wmic -U [domain/]adminuser%password //host \"select * from Win32_ComputerSystem\"");
+
+    while ((opt = poptGetNextOpt(pc)) != -1) {
+       poptPrintUsage(pc, stdout, 0);
        poptFreeContext(pc);
-}
+       exit(1);
+    }
 
-static void escape_string(const char *src, char *dst, int len)
-{
-       char *p = dst, *end = dst + len - 1;
-       const char *q = src;
+    argv_new = discard_const_p(char *, poptGetArgs(pc));
 
-       if ( q == NULL) {
-               strncpy( dst, "(null)", len);
-               return;
+    argc_new = argc;
+    for (i = 0; i < argc; i++) {
+       if (argv_new[i] == NULL) {
+           argc_new = i;
+           break;
        }
+    }
 
-       while ( *q && p <= end ) {
-               if ( strchr( "|\\(),", *q)) {
-                       *p++ = '\\';
-                       *p++ = *q++;
-               } else if ( *q == '\n' ) {
-                       *p++ = '\\';
-                       *p++ = 'n';
-                       q++;
-               } else if ( *q == '\r' ) {
-                       *p++ = '\\';
-                       *p++ = 'r';
-                       q++;
-               } else {
-                       *p++ = *q++;
-               }
-       }
+    if (argc_new != 3 || argv_new[1][0] != '/'
+       || argv_new[1][1] != '/') {
+       poptPrintUsage(pc, stdout, 0);
+       poptFreeContext(pc);
+       exit(1);
+    }
 
-       *p++ = 0;
+    pmyargs->hostname = argv_new[1] + 2;
+    pmyargs->query = argv_new[2];
+    poptFreeContext(pc);
 }
 
 #define WERR_CHECK(msg) if (!W_ERROR_IS_OK(result)) { \
@@ -129,33 +99,20 @@ static void escape_string(const char *src, char *dst, int len)
                            DEBUG(1, ("OK   : %s\n", msg)); \
                        }
 
-#define RETURN_CVAR_ARRAY_STR_START(arr) {\
-        uint32_t i;\
+#define RETURN_CVAR_ARRAY_STR(fmt, arr) {\
+       uint32_t i;\
        char *r;\
 \
-        if (!arr) {\
-                return talloc_strdup(mem_ctx, "(null)");\
-        }\
+       if (!arr) {\
+               return talloc_strdup(mem_ctx, "NULL");\
+       }\
        r = talloc_strdup(mem_ctx, "(");\
-        for (i = 0; i < arr->count; ++i) {
-
-
-#define RETURN_CVAR_ARRAY_STR_END(fmt, arr, item) \
-               r = talloc_asprintf_append(r, fmt "%s", item, (i+1 == arr->count)?"":",");\
-        }\
-        return talloc_asprintf_append(r, ")");\
+       for (i = 0; i < arr->count; ++i) {\
+               r = talloc_asprintf_append(r, fmt "%s", arr->item[i], (i+1 == arr->count)?"":",");\
+       }\
+       return talloc_asprintf_append(r, ")");\
 }
 
-#define RETURN_CVAR_ARRAY_STR(fmt, arr) \
-       RETURN_CVAR_ARRAY_STR_START(arr) \
-       RETURN_CVAR_ARRAY_STR_END(fmt, arr, arr->item[i])
-
-#define RETURN_CVAR_ARRAY_ESCAPED(fmt, arr) \
-       RETURN_CVAR_ARRAY_STR_START(arr) \
-       char buf[2048]; \
-       escape_string( arr->item[i], buf, 2048); \
-       RETURN_CVAR_ARRAY_STR_END(fmt, arr, buf)
-
 char *string_CIMVAR(TALLOC_CTX *mem_ctx, union CIMVAR *v, enum CIMTYPE_ENUMERATION cimtype)
 {
        switch (cimtype) {
@@ -172,11 +129,7 @@ char *string_CIMVAR(TALLOC_CTX *mem_ctx, union CIMVAR *v, enum CIMTYPE_ENUMERATI
        case CIM_BOOLEAN: return talloc_asprintf(mem_ctx, "%s", v->v_boolean?"True":"False");
        case CIM_STRING:
        case CIM_DATETIME:
-       case CIM_REFERENCE: {
-               char buf[2048];
-               escape_string((char*) v-> v_string, buf, 2048);
-               return talloc_asprintf(mem_ctx, "%s", buf);
-       }
+       case CIM_REFERENCE: return talloc_asprintf(mem_ctx, "%s", v->v_string);
        case CIM_CHAR16: return talloc_asprintf(mem_ctx, "Unsupported");
        case CIM_OBJECT: return talloc_asprintf(mem_ctx, "Unsupported");
        case CIM_ARR_SINT8: RETURN_CVAR_ARRAY_STR("%d", v->a_sint8);
@@ -190,9 +143,9 @@ char *string_CIMVAR(TALLOC_CTX *mem_ctx, union CIMVAR *v, enum CIMTYPE_ENUMERATI
        case CIM_ARR_REAL32: RETURN_CVAR_ARRAY_STR("%f", v->a_real32);
        case CIM_ARR_REAL64: RETURN_CVAR_ARRAY_STR("%f", v->a_real64);
        case CIM_ARR_BOOLEAN: RETURN_CVAR_ARRAY_STR("%d", v->a_boolean);
-       case CIM_ARR_STRING: RETURN_CVAR_ARRAY_ESCAPED("%s", v->a_string);
-       case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY_ESCAPED("%s", v->a_datetime);
-       case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY_ESCAPED("%s", v->a_reference);
+       case CIM_ARR_STRING: RETURN_CVAR_ARRAY_STR("%s", v->a_string);
+       case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY_STR("%s", v->a_datetime);
+       case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY_STR("%s", v->a_reference);
        default: return talloc_asprintf(mem_ctx, "Unsupported");
        }
 }

diff --git a/source4/libcli/clifile.c b/source4/libcli/clifile.c
index 2cf174060b7bf33d06d4f660524cb1427ef2bb15..b76bdc015f70dd41ee6f32be391b6c8a61c1a073 100644 (file)
--- a/source4/libcli/clifile.c
+++ b/source4/libcli/clifile.c
@@ -241,7 +241,7 @@ int smbcli_nt_create_full(struct smbcli_tree *tree, const char *fname,
 
        open_parms.ntcreatex.level = RAW_OPEN_NTCREATEX;
        open_parms.ntcreatex.in.flags = CreatFlags;
-       open_parms.ntcreatex.in.root_fid = 0;
+       open_parms.ntcreatex.in.root_fid.fnum = 0;
        open_parms.ntcreatex.in.access_mask = DesiredAccess;
        open_parms.ntcreatex.in.file_attr = FileAttributes;
        open_parms.ntcreatex.in.alloc_size = 0;

diff --git a/source4/libcli/ldap/ldap_client.c b/source4/libcli/ldap/ldap_client.c
index d278f407dcf2da2b44f525b9c42a2fd1522d2068..eb532769362a10d5bd09e51c34789b59cfc5e8c6 100644 (file)
--- a/source4/libcli/ldap/ldap_client.c
+++ b/source4/libcli/ldap/ldap_client.c
@@ -338,7 +338,9 @@ _PUBLIC_ struct composite_context *ldap_connect_send(struct ldap_connection *con
                /* LDAPI connections are to localhost, so give the
                 * local host name as the target for gensec's
                 * DIGEST-MD5 mechanism */
-               conn->host = talloc_asprintf(conn, "%s.%s", lp_netbios_name(conn->lp_ctx),  lp_realm(conn->lp_ctx));
+               conn->host = talloc_asprintf(conn, "%s.%s",
+                                            lp_netbios_name(conn->lp_ctx),
+                                            lp_dnsdomain(conn->lp_ctx));
                if (composite_nomem(conn->host, state->ctx)) {
                        return result;
                }
@@ -403,7 +405,6 @@ static void ldap_connect_got_sock(struct composite_context *ctx,
        talloc_steal(conn, conn->sock);
        if (conn->ldaps) {
                struct socket_context *tls_socket;
-               struct socket_context *tmp_socket;
                char *cafile = lp_tls_cafile(conn->sock, conn->lp_ctx);
 
                if (!cafile || !*cafile) {

diff --git a/source4/libcli/ldap/ldap_controls.c b/source4/libcli/ldap/ldap_controls.c
index aef775fab567119411b56696b53a6befbcaa8418..86493c81da68473501223861e290a5c36c3d436f 100644 (file)
--- a/source4/libcli/ldap/ldap_controls.c
+++ b/source4/libcli/ldap/ldap_controls.c
@@ -214,7 +214,7 @@ static bool decode_sd_flags_request(void *mem_ctx, DATA_BLOB in, void *_out)
                return false;
        }
 
-       if (!asn1_read_Integer(data, &(lsdfc->secinfo_flags))) {
+       if (!asn1_read_Integer(data, (int *) &(lsdfc->secinfo_flags))) {
                return false;
        }
 
@@ -248,7 +248,7 @@ static bool decode_search_options_request(void *mem_ctx, DATA_BLOB in, void *_ou
                return false;
        }
 
-       if (!asn1_read_Integer(data, &(lsoc->search_options))) {
+       if (!asn1_read_Integer(data, (int *) &(lsoc->search_options))) {
                return false;
        }
 

diff --git a/source4/libcli/raw/interfaces.h b/source4/libcli/raw/interfaces.h
index 13217158cbe23302624ecd410cd965b74135da73..af2158cc16a17207f4acbbbba224c15ecf227103 100644 (file)
--- a/source4/libcli/raw/interfaces.h
+++ b/source4/libcli/raw/interfaces.h
@@ -1356,6 +1356,7 @@ enum smb_open_level {
        RAW_OPEN_T2OPEN,
        RAW_OPEN_NTTRANS_CREATE, 
        RAW_OPEN_OPENX_READX,
+       RAW_OPEN_NTCREATEX_READX,
        RAW_OPEN_SMB2
 };
 
@@ -1400,6 +1401,9 @@ union smb_open {
        case RAW_OPEN_OPENX_READX: \
                file = &op->openxreadx.out.file; \
                break; \
+       case RAW_OPEN_NTCREATEX_READX: \
+               file = &op->ntcreatexreadx.out.file; \
+               break; \
        case RAW_OPEN_SMB2: \
                file = &op->smb2.out.file; \
                break; \
@@ -1414,7 +1418,7 @@ union smb_open {
                enum smb_open_level level;
                struct {
                        uint32_t flags;
-                       uint32_t root_fid;
+                       union smb_handle root_fid;
                        uint32_t access_mask;
                        uint64_t alloc_size;
                        uint32_t file_attr;
@@ -1619,6 +1623,54 @@ union smb_open {
                } out;
        } openxreadx;
 
+       /* chained NTCreateX/ReadX interface */
+       struct {
+               enum smb_open_level level;
+               struct {
+                       uint32_t flags;
+                       union smb_handle root_fid;
+                       uint32_t access_mask;
+                       uint64_t alloc_size;
+                       uint32_t file_attr;
+                       uint32_t share_access;
+                       uint32_t open_disposition;
+                       uint32_t create_options;
+                       uint32_t impersonation;
+                       uint8_t  security_flags;
+                       /* NOTE: fname can also be a pointer to a
+                        uint64_t file_id if create_options has the
+                        NTCREATEX_OPTIONS_OPEN_BY_FILE_ID flag set */
+                       const char *fname;
+
+                       /* readx part */
+                       uint64_t offset;
+                       uint16_t mincnt;
+                       uint32_t maxcnt;
+                       uint16_t remaining;
+               } in;
+               struct {
+                       union smb_handle file;
+                       uint8_t oplock_level;
+                       uint32_t create_action;
+                       NTTIME create_time;
+                       NTTIME access_time;
+                       NTTIME write_time;
+                       NTTIME change_time;
+                       uint32_t attrib;
+                       uint64_t alloc_size;
+                       uint64_t size;
+                       uint16_t file_type;
+                       uint16_t ipc_state;
+                       uint8_t  is_directory;
+
+                       /* readx part */
+                       uint8_t *data;
+                       uint16_t remaining;
+                       uint16_t compaction_mode;
+                       uint16_t nread;
+               } out;
+       } ntcreatexreadx;
+
 #define SMB2_CREATE_FLAG_REQUEST_OPLOCK           0x0100
 #define SMB2_CREATE_FLAG_REQUEST_EXCLUSIVE_OPLOCK 0x0800
 #define SMB2_CREATE_FLAG_GRANT_OPLOCK             0x0001

diff --git a/source4/libcli/raw/rawfile.c b/source4/libcli/raw/rawfile.c
index 35d6b75c4d631616b11f8a9d0e076eb0e782b48b..b6849fef618be43f86b3c587c70853174d57927e 100644 (file)
--- a/source4/libcli/raw/rawfile.c
+++ b/source4/libcli/raw/rawfile.c
@@ -379,7 +379,7 @@ static struct smbcli_request *smb_raw_nttrans_create_send(struct smbcli_tree *tr
        params = nt.in.params.data;
 
        SIVAL(params,  0, parms->ntcreatex.in.flags);
-       SIVAL(params,  4, parms->ntcreatex.in.root_fid);
+       SIVAL(params,  4, parms->ntcreatex.in.root_fid.fnum);
        SIVAL(params,  8, parms->ntcreatex.in.access_mask);
        SBVAL(params, 12, parms->ntcreatex.in.alloc_size);
        SIVAL(params, 20, parms->ntcreatex.in.file_attr);
@@ -564,7 +564,7 @@ _PUBLIC_ struct smbcli_request *smb_raw_open_send(struct smbcli_tree *tree, unio
                SSVAL(req->out.vwv, VWV(1),0);
                SCVAL(req->out.vwv, VWV(2),0); /* padding */
                SIVAL(req->out.vwv,  7, parms->ntcreatex.in.flags);
-               SIVAL(req->out.vwv, 11, parms->ntcreatex.in.root_fid);
+               SIVAL(req->out.vwv, 11, parms->ntcreatex.in.root_fid.fnum);
                SIVAL(req->out.vwv, 15, parms->ntcreatex.in.access_mask);
                SBVAL(req->out.vwv, 19, parms->ntcreatex.in.alloc_size);
                SIVAL(req->out.vwv, 27, parms->ntcreatex.in.file_attr);
@@ -616,6 +616,45 @@ _PUBLIC_ struct smbcli_request *smb_raw_open_send(struct smbcli_tree *tree, unio
                        SIVAL(req->out.vwv, VWV(10),parms->openxreadx.in.offset>>32);
                }
                break;
+
+       case RAW_OPEN_NTCREATEX_READX:
+               SETUP_REQUEST(SMBntcreateX, 24, 0);
+               SSVAL(req->out.vwv, VWV(0),SMB_CHAIN_NONE);
+               SSVAL(req->out.vwv, VWV(1),0);
+               SCVAL(req->out.vwv, VWV(2),0); /* padding */
+               SIVAL(req->out.vwv,  7, parms->ntcreatexreadx.in.flags);
+               SIVAL(req->out.vwv, 11, parms->ntcreatexreadx.in.root_fid.fnum);
+               SIVAL(req->out.vwv, 15, parms->ntcreatexreadx.in.access_mask);
+               SBVAL(req->out.vwv, 19, parms->ntcreatexreadx.in.alloc_size);
+               SIVAL(req->out.vwv, 27, parms->ntcreatexreadx.in.file_attr);
+               SIVAL(req->out.vwv, 31, parms->ntcreatexreadx.in.share_access);
+               SIVAL(req->out.vwv, 35, parms->ntcreatexreadx.in.open_disposition);
+               SIVAL(req->out.vwv, 39, parms->ntcreatexreadx.in.create_options);
+               SIVAL(req->out.vwv, 43, parms->ntcreatexreadx.in.impersonation);
+               SCVAL(req->out.vwv, 47, parms->ntcreatexreadx.in.security_flags);
+
+               smbcli_req_append_string_len(req, parms->ntcreatexreadx.in.fname, STR_TERMINATE, &len);
+               SSVAL(req->out.vwv, 5, len);
+
+               if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
+                       bigoffset = true;
+               }
+
+               smbcli_chained_request_setup(req, SMBreadX, bigoffset ? 12 : 10, 0);
+
+               SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
+               SSVAL(req->out.vwv, VWV(1), 0);
+               SSVAL(req->out.vwv, VWV(2), 0);
+               SIVAL(req->out.vwv, VWV(3), parms->ntcreatexreadx.in.offset);
+               SSVAL(req->out.vwv, VWV(5), parms->ntcreatexreadx.in.maxcnt & 0xFFFF);
+               SSVAL(req->out.vwv, VWV(6), parms->ntcreatexreadx.in.mincnt);
+               SIVAL(req->out.vwv, VWV(7), parms->ntcreatexreadx.in.maxcnt >> 16);
+               SSVAL(req->out.vwv, VWV(9), parms->ntcreatexreadx.in.remaining);
+               if (bigoffset) {
+                       SIVAL(req->out.vwv, VWV(10),parms->ntcreatexreadx.in.offset>>32);
+               }
+               break;
+
        case RAW_OPEN_SMB2:
                return NULL;
        }
@@ -753,6 +792,41 @@ _PUBLIC_ NTSTATUS smb_raw_open_recv(struct smbcli_request *req, TALLOC_CTX *mem_
                        req->status = NT_STATUS_BUFFER_TOO_SMALL;
                }
                break;
+
+       case RAW_OPEN_NTCREATEX_READX:
+               SMBCLI_CHECK_MIN_WCT(req, 34);
+               parms->ntcreatexreadx.out.oplock_level =              CVAL(req->in.vwv, 4);
+               parms->ntcreatexreadx.out.file.fnum =                 SVAL(req->in.vwv, 5);
+               parms->ntcreatexreadx.out.create_action =             IVAL(req->in.vwv, 7);
+               parms->ntcreatexreadx.out.create_time =   smbcli_pull_nttime(req->in.vwv, 11);
+               parms->ntcreatexreadx.out.access_time =   smbcli_pull_nttime(req->in.vwv, 19);
+               parms->ntcreatexreadx.out.write_time =    smbcli_pull_nttime(req->in.vwv, 27);
+               parms->ntcreatexreadx.out.change_time =   smbcli_pull_nttime(req->in.vwv, 35);
+               parms->ntcreatexreadx.out.attrib =                   IVAL(req->in.vwv, 43);
+               parms->ntcreatexreadx.out.alloc_size =               BVAL(req->in.vwv, 47);
+               parms->ntcreatexreadx.out.size =                     BVAL(req->in.vwv, 55);
+               parms->ntcreatexreadx.out.file_type =                SVAL(req->in.vwv, 63);
+               parms->ntcreatexreadx.out.ipc_state =                SVAL(req->in.vwv, 65);
+               parms->ntcreatexreadx.out.is_directory =             CVAL(req->in.vwv, 67);
+
+               status = smbcli_chained_advance(req);
+               if (!NT_STATUS_IS_OK(status)) {
+                       return status;
+               }
+
+               SMBCLI_CHECK_WCT(req, 12);
+               parms->ntcreatexreadx.out.remaining       = SVAL(req->in.vwv, VWV(2));
+               parms->ntcreatexreadx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
+               parms->ntcreatexreadx.out.nread = SVAL(req->in.vwv, VWV(5));
+               if (parms->ntcreatexreadx.out.nread >
+                   MAX(parms->ntcreatexreadx.in.mincnt, parms->ntcreatexreadx.in.maxcnt) ||
+                   !smbcli_raw_pull_data(&req->in.bufinfo, req->in.hdr + SVAL(req->in.vwv, VWV(6)),
+                                         parms->ntcreatexreadx.out.nread,
+                                         parms->ntcreatexreadx.out.data)) {
+                       req->status = NT_STATUS_BUFFER_TOO_SMALL;
+               }
+               break;
+
        case RAW_OPEN_SMB2:
                req->status = NT_STATUS_INTERNAL_ERROR;
                break;

diff --git a/source4/libcli/security/access_check.c b/source4/libcli/security/access_check.c
index 543b0f74c5843f94dcee7ab3914ae1c7b1c6221d..954c54c38b86a4860f123cf50a5e0f06080e7155 100644 (file)
--- a/source4/libcli/security/access_check.c
+++ b/source4/libcli/security/access_check.c
@@ -125,9 +125,13 @@ NTSTATUS sec_access_check(const struct security_descriptor *sd,
            security_token_has_sid(token, sd->owner_sid)) {
                bits_remaining &= ~(SEC_STD_WRITE_DAC|SEC_STD_READ_CONTROL|SEC_STD_DELETE);
        }
-       if ((bits_remaining & SEC_STD_DELETE) &&
+       if ((bits_remaining & SEC_RIGHTS_PRIV_RESTORE) &&
            security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
-               bits_remaining &= ~SEC_STD_DELETE;
+               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 (sd->dacl == NULL) {

diff --git a/source4/libcli/security/object_tree.c b/source4/libcli/security/object_tree.c
index 8a90019a59ee39854275e6a08dff360b3b7552ee..85b407913c518d340a03c52f522f6480c737e925 100644 (file)
--- a/source4/libcli/security/object_tree.c
+++ b/source4/libcli/security/object_tree.c
@@ -94,13 +94,13 @@ struct object_tree * get_object_tree_by_GUID(struct object_tree *root,
 /* Change the granted access per each ACE */
 
 void object_tree_modify_access(struct object_tree *root,
-                              uint32_t access)
+                              uint32_t access_mask)
 {
        struct object_tree *p;
        if (root){
-               root->remaining_access &= ~access;
+               root->remaining_access &= ~access_mask;
        }
 
        for (p = root->children; p != NULL; p = p->next)
-               object_tree_modify_access(p, access);
+               object_tree_modify_access(p, access_mask);
 }

diff --git a/source4/libcli/smb2/util.c b/source4/libcli/smb2/util.c
index 8602c91a9f670f28f7474a030f7589ce0239a17f..9b8d6887b146eb427e27474dae39fc9339189db5 100644 (file)
--- a/source4/libcli/smb2/util.c
+++ b/source4/libcli/smb2/util.c
@@ -220,3 +220,12 @@ int smb2_deltree(struct smb2_tree *tree, const char *dname)
 
        return total_deleted;
 }
+
+/*
+  check if two SMB2 file handles are the same
+*/
+bool smb2_util_handle_equal(const struct smb2_handle h1,
+                           const struct smb2_handle h2)
+{
+       return (h1.data[0] == h2.data[0]) && (h1.data[1] == h2.data[1]);
+}

diff --git a/source4/libcli/smb_composite/appendacl.c b/source4/libcli/smb_composite/appendacl.c
index 69ed62a10656bfbaf9c7386e965363c0390ae741..c1a964f151b22747335610b74d0080b95518c82b 100644 (file)
--- a/source4/libcli/smb_composite/appendacl.c
+++ b/source4/libcli/smb_composite/appendacl.c
@@ -254,7 +254,7 @@ struct composite_context *smb_composite_appendacl_send(struct smbcli_tree *tree,
        if (state->io_open == NULL) goto failed;
        
        state->io_open->ntcreatex.level               = RAW_OPEN_NTCREATEX;
-       state->io_open->ntcreatex.in.root_fid = 0;
+       state->io_open->ntcreatex.in.root_fid.fnum    = 0;
        state->io_open->ntcreatex.in.flags            = 0;
        state->io_open->ntcreatex.in.access_mask      = SEC_FLAG_MAXIMUM_ALLOWED;
        state->io_open->ntcreatex.in.file_attr        = FILE_ATTRIBUTE_NORMAL;

diff --git a/source4/libnet/libnet_become_dc.c b/source4/libnet/libnet_become_dc.c
index 38357efffedaa326a6118a3f56379efdbcc51cf1..3fb308dcd7065788f0a7594d8fa9f0769c042876 100644 (file)
--- a/source4/libnet/libnet_become_dc.c
+++ b/source4/libnet/libnet_become_dc.c
@@ -731,6 +731,20 @@ struct libnet_BecomeDC_state {
        struct libnet_BecomeDC_Callbacks callbacks;
 };
 
+static int32_t get_dc_function_level(struct loadparm_context *lp_ctx)
+{
+       /* per default we are (Windows) 2008 compatible */
+       return lp_parm_int(lp_ctx, NULL, "ads", "dc function level",
+               DS_DC_FUNCTION_2008);
+}
+
+static int32_t get_min_function_level(struct loadparm_context *lp_ctx)
+{
+       /* per default it is (Windows) 2003 Native compatible */
+       return lp_parm_int(lp_ctx, NULL, "ads", "min function level",
+               DS_DOMAIN_FUNCTION_2003);
+}
+
 static void becomeDC_recv_cldap(struct tevent_req *req);
 
 static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
@@ -876,6 +890,22 @@ static NTSTATUS becomeDC_ldap1_crossref_behavior_version(struct libnet_BecomeDC_
        }
 
        s->forest.crossref_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
+       if (s->forest.crossref_behavior_version <
+                        get_min_function_level(s->libnet->lp_ctx)) {
+               talloc_free(r);
+               DEBUG(0,("The servers function level %u is below 'ads:min function level' of %u\n", 
+                        s->forest.crossref_behavior_version, 
+                        get_min_function_level(s->libnet->lp_ctx)));
+               return NT_STATUS_NOT_SUPPORTED;
+       }
+       if (s->forest.crossref_behavior_version >
+                       get_dc_function_level(s->libnet->lp_ctx)) {
+               talloc_free(r);
+               DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n", 
+                        s->forest.crossref_behavior_version, 
+                        get_dc_function_level(s->libnet->lp_ctx)));
+               return NT_STATUS_NOT_SUPPORTED;
+       }
 
        talloc_free(r);
        return NT_STATUS_OK;
@@ -905,6 +935,22 @@ static NTSTATUS becomeDC_ldap1_domain_behavior_version(struct libnet_BecomeDC_st
        }
 
        s->domain.behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
+       if (s->domain.behavior_version <
+                       get_min_function_level(s->libnet->lp_ctx)) {
+               talloc_free(r);
+               DEBUG(0,("The servers function level %u is below 'ads:min function level' of %u\n", 
+                        s->forest.crossref_behavior_version, 
+                        get_min_function_level(s->libnet->lp_ctx)));
+               return NT_STATUS_NOT_SUPPORTED;
+       }
+       if (s->domain.behavior_version >
+                       get_dc_function_level(s->libnet->lp_ctx)) {
+               talloc_free(r);
+               DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n", 
+                        s->forest.crossref_behavior_version, 
+                        get_dc_function_level(s->libnet->lp_ctx)));
+               return NT_STATUS_NOT_SUPPORTED;
+       }
 
        talloc_free(r);
        return NT_STATUS_OK;
@@ -1282,8 +1328,8 @@ static NTSTATUS becomeDC_ldap1_server_object_1(struct libnet_BecomeDC_state *s)
                NT_STATUS_HAVE_NO_MEMORY(computer_dn);
 
                /*
-                * if the server object belongs to another DC in another domain in the forest,
-                * we should not touch this object!
+                * if the server object belongs to another DC in another domain
+                * in the forest, we should not touch this object!
                 */
                if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
                        talloc_free(r);
@@ -1519,9 +1565,10 @@ static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
                 * Note: Replication only works with Windows 2000 when 'krb5' is
                 *       passed as auth_type here. If NTLMSSP is used, Windows
                 *       2000 returns garbage in the DsGetNCChanges() response
-                *       if encrypted password attributes would be in the response.
-                *       That means the replication of the schema and configuration
-                *       partition works fine, but it fails for the domain partition.
+                *       if encrypted password attributes would be in the
+                *       response. That means the replication of the schema and
+                *       configuration partition works fine, but it fails for
+                *       the domain partition.
                 */
                if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
                                 "force krb5", true))
@@ -1589,7 +1636,7 @@ static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
        bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
        bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
        bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
-       if (s->domain.behavior_version == 2) {
+       if (s->domain.behavior_version >= DS_DOMAIN_FUNCTION_2003) {
                /* TODO: find out how this is really triggered! */
                bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
        }
@@ -1716,8 +1763,8 @@ static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
        s->dest_dsa.invocation_id = GUID_random();
 
        /*
-        * if the schema version indicates w2k3, then
-        * also send some w2k3 specific attributes
+        * if the schema version indicates w2k3, then also send some w2k3
+        * specific attributes.
         */
        if (s->forest.schema_object_version >= 30) {
                w2k3 = true;
@@ -2101,8 +2148,7 @@ static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
                vd[0] = data_blob_talloc(vd, NULL, 4);
                if (composite_nomem(vd[0].data, c)) return;
 
-               SIVAL(vd[0].data, 0, 
-                     lp_parm_int(s->libnet->lp_ctx, NULL, "ads", "functional level", DS_DC_FUNCTION_2008));
+               SIVAL(vd[0].data, 0, get_dc_function_level(s->libnet->lp_ctx));
 
                vs[0].blob              = &vd[0];
 

diff --git a/source4/libnet/libnet_samsync.c b/source4/libnet/libnet_samsync.c
index 1d5e41de0533c56aa002ada147b90ca5116c8b65..bdfb46dfd9869c39debe921144f679daa78892af 100644 (file)
--- a/source4/libnet/libnet_samsync.c
+++ b/source4/libnet/libnet_samsync.c
@@ -26,7 +26,7 @@
 #include "../libcli/samsync/samsync.h"
 #include "auth/gensec/gensec.h"
 #include "auth/credentials/credentials.h"
-#include "auth/gensec/schannel_proto.h"
+#include "libcli/auth/schannel.h"
 #include "librpc/gen_ndr/ndr_netlogon.h"
 #include "librpc/gen_ndr/ndr_netlogon_c.h"
 #include "param/param.h"

diff --git a/source4/librpc/rpc/dcerpc_smb.c b/source4/librpc/rpc/dcerpc_smb.c
index f4e6b8c3dd3bb697a8c8ba7165c1008614c0f15c..947a9c5f657b333edd5207a76e24557deb141420 100644 (file)
--- a/source4/librpc/rpc/dcerpc_smb.c
+++ b/source4/librpc/rpc/dcerpc_smb.c
@@ -476,7 +476,7 @@ struct composite_context *dcerpc_pipe_open_smb_send(struct dcerpc_pipe *p,
 
        state->open->ntcreatex.level = RAW_OPEN_NTCREATEX;
        state->open->ntcreatex.in.flags = 0;
-       state->open->ntcreatex.in.root_fid = 0;
+       state->open->ntcreatex.in.root_fid.fnum = 0;
        state->open->ntcreatex.in.access_mask = 
                SEC_STD_READ_CONTROL |
                SEC_FILE_WRITE_ATTRIBUTE |

diff --git a/source4/librpc/rpc/pyrpc.h b/source4/librpc/rpc/pyrpc.h
index ae622b562c6de5db02a0d3abb7ed2a89e9f21cb3..efbcac688cea997cb53eabe5b27c6441cbadbfc6 100644 (file)
--- a/source4/librpc/rpc/pyrpc.h
+++ b/source4/librpc/rpc/pyrpc.h
@@ -53,7 +53,7 @@ PyAPI_DATA(PyTypeObject) dcerpc_InterfaceType;
 #define PyErr_SetNdrError(err) \
                PyErr_SetObject(PyExc_RuntimeError, PyErr_FromNdrError(err))
 
-void PyErr_SetDCERPCStatus(struct dcerpc_pipe *pipe, NTSTATUS status);
+void PyErr_SetDCERPCStatus(struct dcerpc_pipe *p, NTSTATUS status);
 
 typedef bool (*py_data_pack_fn) (PyObject *args, PyObject *kwargs, void *r);
 typedef PyObject *(*py_data_unpack_fn) (void *r);

diff --git a/source4/nbt_server/wins/winsdb.c b/source4/nbt_server/wins/winsdb.c
index 5c3efe2b83c9803b0de0e6365962381680fd3d24..a502050299eb86e2b32e73a54c4fea1a435841d3 100644 (file)
--- a/source4/nbt_server/wins/winsdb.c
+++ b/source4/nbt_server/wins/winsdb.c
@@ -100,17 +100,17 @@ uint64_t winsdb_set_maxVersion(struct winsdb_handle *h, uint64_t newMaxVersion)
 
 
        ret = ldb_msg_add_empty(msg, "objectClass", LDB_FLAG_MOD_REPLACE, NULL);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
        ret = ldb_msg_add_string(msg, "objectClass", "winsMaxVersion");
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
        ret = ldb_msg_add_empty(msg, "maxVersion", LDB_FLAG_MOD_REPLACE, NULL);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
        ret = ldb_msg_add_fmt(msg, "maxVersion", "%llu", (long long)newMaxVersion);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
 
        ret = ldb_modify(wins_db, msg);
-       if (ret != 0) ret = ldb_add(wins_db, msg);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) ret = ldb_add(wins_db, msg);
+       if (ret != LDB_SUCCESS) goto failed;
 
        trans = ldb_transaction_commit(wins_db);
        if (trans != LDB_SUCCESS) goto failed;
@@ -259,7 +259,7 @@ static NTSTATUS winsdb_addr_decode(struct winsdb_handle *h, struct winsdb_record
                return NT_STATUS_OK;
        }
 
-       *p = '\0';p++;
+       *p = '\0'; p++;
        addr->address = talloc_strdup(addr, address);
        if (!addr->address) {
                status = NT_STATUS_NO_MEMORY;
@@ -324,16 +324,16 @@ static int ldb_msg_add_winsdb_addr(struct ldb_message *msg, struct winsdb_record
 
        if (rec->is_static) {
                str = talloc_strdup(msg, addr->address);
-               if (!str) return -1;
+               if (!str) return LDB_ERR_OPERATIONS_ERROR;
        } else {
                char *expire_time;
                expire_time = ldb_timestring(msg, addr->expire_time);
-               if (!expire_time) return -1;
+               if (!expire_time) return LDB_ERR_OPERATIONS_ERROR;
                str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
                                      addr->address, addr->wins_owner,
                                      expire_time);
                talloc_free(expire_time);
-               if (!str) return -1;
+               if (!str) return LDB_ERR_OPERATIONS_ERROR;
        }
 
        val.data = discard_const_p(uint8_t, str);
@@ -750,7 +750,7 @@ static struct ldb_message *winsdb_message(struct ldb_context *ldb,
                                          struct winsdb_record *rec,
                                          TALLOC_CTX *mem_ctx)
 {
-       int i, ret=0;
+       int i, ret;
        size_t addr_count;
        const char *expire_time;
        struct ldb_message *msg = ldb_msg_new(mem_ctx);
@@ -772,7 +772,7 @@ static struct ldb_message *winsdb_message(struct ldb_context *ldb,
 
        msg->dn = winsdb_dn(msg, ldb, rec->name);
        if (msg->dn == NULL) goto failed;
-       ret |= ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type);
+       ret = ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type);
        if (rec->name->name && *rec->name->name) {
                ret |= ldb_msg_add_string(msg, "name", rec->name->name);
        }
@@ -794,11 +794,11 @@ static struct ldb_message *winsdb_message(struct ldb_context *ldb,
        for (i=0;rec->addresses[i];i++) {
                ret |= ldb_msg_add_winsdb_addr(msg, rec, "address", rec->addresses[i]);
        }
-       ret |= ldb_msg_add_empty(msg, "registeredBy", 0, NULL);
        if (rec->registered_by) {
+               ret |= ldb_msg_add_empty(msg, "registeredBy", 0, NULL);
                ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
-               if (ret != 0) goto failed;
        }
+       if (ret != LDB_SUCCESS) goto failed;
        return msg;
 
 failed:
@@ -815,7 +815,7 @@ uint8_t winsdb_add(struct winsdb_handle *h, struct winsdb_record *rec, uint32_t
        struct ldb_context *wins_db = h->ldb;
        TALLOC_CTX *tmp_ctx = talloc_new(wins_db);
        int trans = -1;
-       int ret = 0;
+       int ret;
 
        trans = ldb_transaction_start(wins_db);
        if (trans != LDB_SUCCESS) goto failed;
@@ -832,7 +832,7 @@ uint8_t winsdb_add(struct winsdb_handle *h, struct winsdb_record *rec, uint32_t
        msg = winsdb_message(wins_db, rec, tmp_ctx);
        if (msg == NULL) goto failed;
        ret = ldb_add(wins_db, msg);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
 
        trans = ldb_transaction_commit(wins_db);
        if (trans != LDB_SUCCESS) goto failed;
@@ -881,7 +881,7 @@ uint8_t winsdb_modify(struct winsdb_handle *h, struct winsdb_record *rec, uint32
        }
 
        ret = ldb_modify(wins_db, msg);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
 
        trans = ldb_transaction_commit(wins_db);
        if (trans != LDB_SUCCESS) goto failed;
@@ -916,7 +916,7 @@ uint8_t winsdb_delete(struct winsdb_handle *h, struct winsdb_record *rec)
        if (dn == NULL) goto failed;
 
        ret = ldb_delete(wins_db, dn);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
 
        trans = ldb_transaction_commit(wins_db);
        if (trans != LDB_SUCCESS) goto failed;
@@ -962,10 +962,10 @@ static bool winsdb_check_or_add_module_list(struct tevent_context *ev_ctx,
        msg->dn = dn;
 
        ret = ldb_msg_add_string(msg, "@LIST", "wins_ldb");
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
 
        ret = ldb_add(h->ldb, msg);
-       if (ret != 0) goto failed;
+       if (ret != LDB_SUCCESS) goto failed;
 
        trans = ldb_transaction_commit(h->ldb);
        if (trans != LDB_SUCCESS) goto failed;
@@ -1037,3 +1037,4 @@ failed:
        talloc_free(h);
        return NULL;
 }
+

diff --git a/source4/ntptr/simple_ldb/ntptr_simple_ldb.c b/source4/ntptr/simple_ldb/ntptr_simple_ldb.c
index 601f7902df639ae077296cfc198678717ba059cb..e179f52926ba8e3596674db26e652efc69677ebe 100644 (file)
--- a/source4/ntptr/simple_ldb/ntptr_simple_ldb.c
+++ b/source4/ntptr/simple_ldb/ntptr_simple_ldb.c
@@ -208,12 +208,14 @@ static WERROR sptr_GetPrintServerData(struct ntptr_GenericHandle *server, TALLOC
                r->out.data->binary     = blob;
                return WERR_OK;
        } else if (strcmp("DNSMachineName", r->in.value_name) == 0) {
-               if (!lp_realm(server->ntptr->lp_ctx)) return WERR_INVALID_PARAM;
+               const char *dnsdomain = lp_dnsdomain(server->ntptr->lp_ctx);
+
+               if (dnsdomain == NULL) return WERR_INVALID_PARAM;
 
                *r->out.type            = REG_SZ;
                r->out.data->string     = talloc_asprintf(mem_ctx, "%s.%s",
-                                                                  lp_netbios_name(server->ntptr->lp_ctx),
-                                                                  lp_realm(server->ntptr->lp_ctx));
+                                                         lp_netbios_name(server->ntptr->lp_ctx),
+                                                         dnsdomain);
                W_ERROR_HAVE_NO_MEMORY(r->out.data->string);
                return WERR_OK;
        }

diff --git a/source4/ntvfs/ntvfs_generic.c b/source4/ntvfs/ntvfs_generic.c
index 5838178d9e225c952c7db3a323cb7f95cf5ca742..6e2e075f1e2db3898a92682caff538c1e5f07e78 100644 (file)
--- a/source4/ntvfs/ntvfs_generic.c
+++ b/source4/ntvfs/ntvfs_generic.c
@@ -515,7 +515,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
                        io2->generic.in.flags = 0;
                        break;
                }
-               io2->generic.in.root_fid        = 0;
+               io2->generic.in.root_fid.fnum   = 0;
                io2->generic.in.access_mask     = io->smb2.in.desired_access;
                io2->generic.in.alloc_size      = io->smb2.in.alloc_size;
                io2->generic.in.file_attr       = io->smb2.in.file_attributes;

diff --git a/source4/ntvfs/posix/pvfs_acl.c b/source4/ntvfs/posix/pvfs_acl.c
index ad7ac5a7494a8f9dc9a8997cfc3a40a0613f103f..26515cfe1a6249cfc4a9ea3b462d085196b468ef 100644 (file)
--- a/source4/ntvfs/posix/pvfs_acl.c
+++ b/source4/ntvfs/posix/pvfs_acl.c
@@ -384,6 +384,9 @@ NTSTATUS pvfs_acl_set(struct pvfs_state *pvfs,
                } else {
                        ret = fchown(fd, new_uid, new_gid);
                }
+               if (errno == EPERM && uwrap_enabled()) {
+                       ret = 0;
+               }
                if (ret == -1) {
                        return pvfs_map_errno(pvfs, errno);
                }
@@ -490,16 +493,16 @@ NTSTATUS pvfs_access_check_unix(struct pvfs_state *pvfs,
 {
        uid_t uid = geteuid();
        uint32_t max_bits = SEC_RIGHTS_FILE_READ | SEC_FILE_ALL;
+       struct security_token *token = req->session_info->security_token;
 
        if (pvfs_read_only(pvfs, *access_mask)) {
                return NT_STATUS_ACCESS_DENIED;
        }
 
-       /* owner and root get extra permissions */
-       if (uid == 0) {
-               max_bits |= SEC_STD_ALL | SEC_FLAG_SYSTEM_SECURITY;
-       } else if (uid == name->st.st_uid) {
+       if (uid == name->st.st_uid) {
                max_bits |= SEC_STD_ALL;
+       } else if (security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
+               max_bits |= SEC_STD_DELETE;
        }
 
        if ((name->st.st_mode & S_IWOTH) ||
@@ -516,13 +519,23 @@ NTSTATUS pvfs_access_check_unix(struct pvfs_state *pvfs,
                max_bits |= SEC_STD_ALL;
        }
 
-       if (*access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
-               *access_mask = max_bits;
-               return NT_STATUS_OK;
+       if (*access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
+               *access_mask |= max_bits;
+               *access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
        }
 
-       if (uid != 0 && (*access_mask & SEC_FLAG_SYSTEM_SECURITY)) {
-               return NT_STATUS_ACCESS_DENIED;
+       if ((*access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
+           security_token_has_privilege(token, SEC_PRIV_SECURITY)) {
+               max_bits |= SEC_FLAG_SYSTEM_SECURITY;
+       }
+       
+       if (((*access_mask & ~max_bits) & SEC_RIGHTS_PRIV_RESTORE) &&
+           security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
+               max_bits |= ~(SEC_RIGHTS_PRIV_RESTORE);
+       }
+       if (((*access_mask & ~max_bits) & SEC_RIGHTS_PRIV_BACKUP) &&
+           security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
+               max_bits |= ~(SEC_RIGHTS_PRIV_BACKUP);
        }
 
        if (*access_mask & ~max_bits) {

diff --git a/source4/ntvfs/posix/pvfs_open.c b/source4/ntvfs/posix/pvfs_open.c
index 46e39a00dd46c51716ce81f8922cf77e81aa5d35..e8f1c0c4c8c7c3154e20795576201a87f62a6f56 100644 (file)
--- a/source4/ntvfs/posix/pvfs_open.c
+++ b/source4/ntvfs/posix/pvfs_open.c
@@ -1272,6 +1272,21 @@ NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs,
                return NT_STATUS_ACCESS_DENIED;
        }
 
+       /* cope with non-zero root_fid */
+       if (io->ntcreatex.in.root_fid.ntvfs != NULL) {
+               f = pvfs_find_fd(pvfs, req, io->ntcreatex.in.root_fid.ntvfs);
+               if (f == NULL) {
+                       return NT_STATUS_INVALID_HANDLE;
+               }
+               if (f->handle->fd != -1) {
+                       return NT_STATUS_INVALID_DEVICE_REQUEST;
+               }
+               io->ntcreatex.in.fname = talloc_asprintf(req, "%s\\%s", 
+                                                        f->handle->name->original_name,
+                                                        io->ntcreatex.in.fname);
+               NT_STATUS_HAVE_NO_MEMORY(io->ntcreatex.in.fname);                       
+       }
+
        if (io->ntcreatex.in.file_attr & (FILE_ATTRIBUTE_DEVICE|
                                          FILE_ATTRIBUTE_VOLUME| 
                                          (~FILE_ATTRIBUTE_ALL_MASK))) {

diff --git a/source4/ntvfs/simple/vfs_simple.c b/source4/ntvfs/simple/vfs_simple.c
index aabaa3c47f7852961ddf89afd353a1d139e417b5..9577e8673a504496f31ee7a1fe5f2ec8fe984974 100644 (file)
--- a/source4/ntvfs/simple/vfs_simple.c
+++ b/source4/ntvfs/simple/vfs_simple.c
@@ -70,9 +70,9 @@ static NTSTATUS svfs_connect(struct ntvfs_module_context *ntvfs,
        }
 
        if (strncmp(sharename, "\\\\", 2) == 0) {
-               char *p = strchr(sharename+2, '\\');
-               if (p) {
-                       sharename = p + 1;
+               char *p2 = strchr(sharename+2, '\\');
+               if (p2) {
+                       sharename = p2 + 1;
                }
        }
 

diff --git a/source4/ntvfs/unixuid/vfs_unixuid.c b/source4/ntvfs/unixuid/vfs_unixuid.c
index 97c306f7c3542e291a0814cb0d80d6fa4ce145c4..70ad6ee253411b15d4f8a91ca337982232ddd022 100644 (file)
--- a/source4/ntvfs/unixuid/vfs_unixuid.c
+++ b/source4/ntvfs/unixuid/vfs_unixuid.c
@@ -235,7 +235,10 @@ static NTSTATUS unixuid_setup_security(struct ntvfs_module_context *ntvfs,
        struct unix_sec_ctx *newsec;
        NTSTATUS status;
 
-       if (req->session_info == NULL) {
+       /* If we are asked to set up, but have not had a successful
+        * session setup or tree connect, then these may not be filled
+        * in.  ACCESS_DENIED is the right error code here */
+       if (req->session_info == NULL || priv == NULL) {
                return NT_STATUS_ACCESS_DENIED;
        }
 

diff --git a/source4/param/loadparm.c b/source4/param/loadparm.c
index f7cd95bf4c04d117d8e1b6743ec424de573d6cf7..882de1330e8e7477061ff61438948c86bc05f398 100644 (file)
--- a/source4/param/loadparm.c
+++ b/source4/param/loadparm.c
@@ -103,6 +103,8 @@ struct loadparm_global
        const char **szPasswordServers;
        char *szSocketOptions;
        char *szRealm;
+       char *szRealm_upper;
+       char *szRealm_lower;
        const char **szWINSservers;
        const char **szInterfaces;
        char *szSocketAddress;
@@ -234,6 +236,8 @@ struct loadparm_service
 /* prototypes for the special type handlers */
 static bool handle_include(struct loadparm_context *lp_ctx,
                           const char *pszParmValue, char **ptr);
+static bool handle_realm(struct loadparm_context *lp_ctx,
+                        const char *pszParmValue, char **ptr);
 static bool handle_copy(struct loadparm_context *lp_ctx,
                        const char *pszParmValue, char **ptr);
 static bool handle_debuglevel(struct loadparm_context *lp_ctx,
@@ -339,7 +343,7 @@ static struct parm_struct parm_table[] = {
        {"path", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
        {"directory", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
        {"workgroup", P_USTRING, P_GLOBAL, GLOBAL_VAR(szWorkgroup), NULL, NULL},
-       {"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), NULL, NULL},
+       {"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), handle_realm, NULL},
        {"netbios name", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosName), NULL, NULL},
        {"netbios aliases", P_LIST, P_GLOBAL, GLOBAL_VAR(szNetbiosAliases), NULL, NULL},
        {"netbios scope", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosScope), NULL, NULL},
@@ -648,7 +652,8 @@ _PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, szAutoServices)
 _PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, szPasswdChat)
 _PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, szPasswordServers)
 _PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, szNameResolveOrder)
-_PUBLIC_ FN_GLOBAL_STRING(lp_realm, szRealm)
+_PUBLIC_ FN_GLOBAL_STRING(lp_realm, szRealm_upper)
+_PUBLIC_ FN_GLOBAL_STRING(lp_dnsdomain, szRealm_lower)
 _PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, socket_options)
 _PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, szWorkgroup)
 _PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, szNetbiosName)
@@ -657,7 +662,6 @@ _PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, szWINSservers)
 _PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, szInterfaces)
 _PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, szSocketAddress)
 _PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, szNetbiosAliases)
-
 _PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
 _PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, bWINSsupport)
 _PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, bWINSdnsProxy)
@@ -695,6 +699,7 @@ _PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, cli_minprotocol)
 _PUBLIC_ FN_GLOBAL_INTEGER(lp_security, security)
 _PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
 _PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, announce_as)
+
 const char *lp_servicename(const struct loadparm_service *service)
 {
        return lp_string((const char *)service->szService);
@@ -1447,6 +1452,21 @@ bool lp_file_list_changed(struct loadparm_context *lp_ctx)
        return false;
 }
 
+/***************************************************************************
+ Handle the "realm" parameter
+***************************************************************************/
+
+static bool handle_realm(struct loadparm_context *lp_ctx,
+                        const char *pszParmValue, char **ptr)
+{
+       string_set(lp_ctx, ptr, pszParmValue);
+
+       lp_ctx->globals->szRealm_upper = strupper_talloc(lp_ctx, pszParmValue);
+       lp_ctx->globals->szRealm_lower = strlower_talloc(lp_ctx, pszParmValue);
+
+       return true;
+}
+
 /***************************************************************************
  Handle the include operation.
 ***************************************************************************/

diff --git a/source4/param/param.h b/source4/param/param.h
index 5c49f34e2a2f449c48c0b0e77ef3636de41469f2..0c8e73ecaa458f76d790db315aa85b16c9c20fe1 100644 (file)
--- a/source4/param/param.h
+++ b/source4/param/param.h
@@ -115,6 +115,7 @@ const char *lp_passwd_chat(struct loadparm_context *);
 const char **lp_passwordserver(struct loadparm_context *);
 const char **lp_name_resolve_order(struct loadparm_context *);
 const char *lp_realm(struct loadparm_context *);
+const char *lp_dnsdomain(struct loadparm_context *);
 const char *lp_socket_options(struct loadparm_context *);
 const char *lp_workgroup(struct loadparm_context *);
 const char *lp_netbios_name(struct loadparm_context *);

diff --git a/source4/param/provision.c b/source4/param/provision.c
index cb74f9682008aba4d0e417e8ea317db7d2e93d10..ddf3eec1b9243b5537aa3638e3b250c1904ec851 100644 (file)
--- a/source4/param/provision.c
+++ b/source4/param/provision.c
@@ -247,8 +247,6 @@ NTSTATUS provision_store_self_join(TALLOC_CTX *mem_ctx, struct loadparm_context
                             PyLdb_FromLdbContext(ldb));
        PyDict_SetItemString(parameters, "domain", 
                             PyString_FromString(settings->domain_name));
-       PyDict_SetItemString(parameters, "domain", 
-                            PyString_FromString(settings->domain_name));
        PyDict_SetItemString(parameters, "realm", 
                             PyString_FromString(settings->realm));
        PyDict_SetItemString(parameters, "machinepass", 

diff --git a/source4/rpc_server/common/common.h b/source4/rpc_server/common/common.h
index 17c2a7db023e0060b227ecd01ad5a321c3562c22..ba023e1fd8de512622b2ddfbcc24829d70224068 100644 (file)
--- a/source4/rpc_server/common/common.h
+++ b/source4/rpc_server/common/common.h
@@ -26,6 +26,8 @@
 struct share_config;
 struct dcesrv_context;
 struct dcesrv_context;
+struct dcesrv_call_state;
+struct ndr_interface_table;
 
 struct dcerpc_server_info { 
        const char *domain_name;
@@ -34,8 +36,6 @@ struct dcerpc_server_info {
        uint32_t version_build;
 };
 
-struct ndr_interface_table;
-struct dcesrv_call_state;
 #include "rpc_server/common/proto.h"
 
 #endif /* _DCERPC_SERVER_COMMON_H_ */

diff --git a/source4/rpc_server/dcerpc_server.c b/source4/rpc_server/dcerpc_server.c
index df0c2e73453a2f3106ea80ebfed5c684765112d4..75c50354590323aeec9674b677720be3310e36a9 100644 (file)
--- a/source4/rpc_server/dcerpc_server.c
+++ b/source4/rpc_server/dcerpc_server.c
@@ -336,13 +336,10 @@ NTSTATUS dcesrv_inherited_session_key(struct dcesrv_connection *p,
        return NT_STATUS_NO_USER_SESSION_KEY;
 }
 
-NTSTATUS dcesrv_generic_session_key(struct dcesrv_connection *p,
+NTSTATUS dcesrv_generic_session_key(struct dcesrv_connection *c,
                                    DATA_BLOB *session_key)
 {
-       /* this took quite a few CPU cycles to find ... */
-       session_key->data = discard_const_p(uint8_t, "SystemLibraryDTC");
-       session_key->length = 16;
-       return NT_STATUS_OK;
+       return dcerpc_generic_session_key(NULL, session_key);
 }
 
 /*

diff --git a/source4/rpc_server/drsuapi/addentry.c b/source4/rpc_server/drsuapi/addentry.c
index 7bf8f3959262ea102b6d39979d2902f91489ea00..dbaf6271304d738f06514f8de0a5f1676721bd33 100644 (file)
--- a/source4/rpc_server/drsuapi/addentry.c
+++ b/source4/rpc_server/drsuapi/addentry.c
@@ -82,7 +82,7 @@ static WERROR drsuapi_add_SPNs(struct drsuapi_bind_state *b_state,
 
                ntds_guid_str = GUID_string(res, &ntds_guid);
 
-               dom_string = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
+               dom_string = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
 
                /*
                 * construct a modify request to add the new SPNs to
@@ -180,6 +180,7 @@ WERROR dcesrv_drsuapi_DsAddEntry(struct dcesrv_call_state *dce_call, TALLOC_CTX
                if (!W_ERROR_IS_OK(status)) {
                        r->out.ctr->ctr3.error->info1.status = status;
                        ldb_transaction_cancel(b_state->sam_ctx);
+                       DEBUG(0,(__location__ ": DsAddEntry failed - %s\n", win_errstr(status)));
                        return status;
                }
 
@@ -198,11 +199,13 @@ WERROR dcesrv_drsuapi_DsAddEntry(struct dcesrv_call_state *dce_call, TALLOC_CTX
        if (!W_ERROR_IS_OK(status)) {
                r->out.ctr->ctr3.error->info1.status = status;
                ldb_transaction_cancel(b_state->sam_ctx);
+               DEBUG(0,(__location__ ": DsAddEntry add SPNs failed - %s\n", win_errstr(status)));
                return status;
        }
 
        ret = ldb_transaction_commit(b_state->sam_ctx);
        if (ret != LDB_SUCCESS) {
+               DEBUG(0,(__location__ ": DsAddEntry commit failed\n"));
                return WERR_DS_DRA_INTERNAL_ERROR;
        }
 

diff --git a/source4/rpc_server/drsuapi/dcesrv_drsuapi.c b/source4/rpc_server/drsuapi/dcesrv_drsuapi.c
index 9903f0874633ec8a3e370795f46d36016d0a957f..9f903716dc382eb9a75886c57efb9cc82dc3c9a6 100644 (file)
--- a/source4/rpc_server/drsuapi/dcesrv_drsuapi.c
+++ b/source4/rpc_server/drsuapi/dcesrv_drsuapi.c
@@ -27,6 +27,7 @@
 #include "dsdb/samdb/samdb.h"
 #include "rpc_server/drsuapi/dcesrv_drsuapi.h"
 #include "libcli/security/security.h"
+#include "auth/auth.h"
 
 /* 
   drsuapi_DsBind 
@@ -47,6 +48,8 @@ static WERROR dcesrv_drsuapi_DsBind(struct dcesrv_call_state *dce_call, TALLOC_C
        uint32_t pid;
        uint32_t repl_epoch;
        int ret;
+       struct auth_session_info *auth_info;
+       WERROR werr;
 
        r->out.bind_info = NULL;
        ZERO_STRUCTP(r->out.bind_handle);
@@ -54,10 +57,20 @@ static WERROR dcesrv_drsuapi_DsBind(struct dcesrv_call_state *dce_call, TALLOC_C
        b_state = talloc_zero(mem_ctx, struct drsuapi_bind_state);
        W_ERROR_HAVE_NO_MEMORY(b_state);
 
+       /* if this is a DC connecting, give them system level access */
+       werr = drs_security_level_check(dce_call, NULL);
+       if (W_ERROR_IS_OK(werr)) {
+               DEBUG(2,(__location__ ": doing DsBind with system_session\n"));
+               auth_info = system_session(b_state, dce_call->conn->dce_ctx->lp_ctx);
+       } else {
+               auth_info = dce_call->conn->auth_state.session_info;
+       }
+
        /*
         * connect to the samdb
         */
-       b_state->sam_ctx = samdb_connect(b_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info); 
+       b_state->sam_ctx = samdb_connect(b_state, dce_call->event_ctx, 
+                                        dce_call->conn->dce_ctx->lp_ctx, auth_info); 
        if (!b_state->sam_ctx) {
                return WERR_FOOBAR;
        }

diff --git a/source4/rpc_server/drsuapi/dcesrv_drsuapi.h b/source4/rpc_server/drsuapi/dcesrv_drsuapi.h
index 82899c84322c6fa1fb54749215933acb679789f5..e42d9569e7db449cae9fc70af6b28968c61f1a38 100644 (file)
--- a/source4/rpc_server/drsuapi/dcesrv_drsuapi.h
+++ b/source4/rpc_server/drsuapi/dcesrv_drsuapi.h
@@ -39,6 +39,8 @@ struct drsuapi_bind_state {
 
 
 /* prototypes of internal functions */
+WERROR drsuapi_UpdateRefs(struct drsuapi_bind_state *b_state, TALLOC_CTX *mem_ctx,
+                         struct drsuapi_DsReplicaUpdateRefsRequest1 *req);
 WERROR dcesrv_drsuapi_DsReplicaUpdateRefs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                                          struct drsuapi_DsReplicaUpdateRefs *r);
 WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,

diff --git a/source4/rpc_server/drsuapi/drsutil.c b/source4/rpc_server/drsuapi/drsutil.c
index 84bb5ffc019bc3acc3e2ca56e815e09bde54d5a8..752861cc26272c4877a326f0f242183a0676f945 100644 (file)
--- a/source4/rpc_server/drsuapi/drsutil.c
+++ b/source4/rpc_server/drsuapi/drsutil.c
@@ -98,7 +98,7 @@ int drsuapi_search_with_extended_dn(struct ldb_context *ldb,
                sort_control[0] = talloc(req, struct ldb_server_sort_control);
                sort_control[0]->attributeName = sort_attrib;
                sort_control[0]->orderingRule = NULL;
-               sort_control[0]->reverse = 1;
+               sort_control[0]->reverse = 0;
                sort_control[1] = NULL;
 
                ret = ldb_request_add_control(req, LDB_CONTROL_SERVER_SORT_OID, true, sort_control);
@@ -127,7 +127,9 @@ WERROR drs_security_level_check(struct dcesrv_call_state *dce_call, const char*
 
        if (security_session_user_level(dce_call->conn->auth_state.session_info) <
                SECURITY_DOMAIN_CONTROLLER) {
-               DEBUG(0,("DsReplicaGetInfo refused for security token\n"));
+               if (call) {
+                       DEBUG(0,("%s refused for security token\n", call));
+               }
                return WERR_DS_DRA_ACCESS_DENIED;
        }
 

diff --git a/source4/rpc_server/drsuapi/getncchanges.c b/source4/rpc_server/drsuapi/getncchanges.c
index 2bfdf5280ac0842c094b4c87303b56d27fa23cfc..90ddab083c703e45df5a9b870215375770d438d9 100644 (file)
--- a/source4/rpc_server/drsuapi/getncchanges.c
+++ b/source4/rpc_server/drsuapi/getncchanges.c
@@ -66,7 +66,7 @@ static WERROR get_nc_changes_build_object(struct drsuapi_DsReplicaObjectListItem
                if (instance_type & INSTANCE_TYPE_IS_NC_HEAD) {
                        struct ldb_result *res;
                        int ret;
-                       char *dnstr = ldb_dn_get_linearized(msg->dn);
+                       const char *dnstr = ldb_dn_get_linearized(msg->dn);
                        msg->dn = ldb_dn_new(msg, sam_ctx, dnstr);
                        /* we need to re-search the msg, to avoid the
                         * broken dual message problems with our
@@ -141,8 +141,10 @@ static WERROR get_nc_changes_build_object(struct drsuapi_DsReplicaObjectListItem
                   instanceType then don't include it */
                if (md.ctr.ctr1.array[i].local_usn < highest_usn &&
                    md.ctr.ctr1.array[i].attid != DRSUAPI_ATTRIBUTE_instanceType) continue;
+
                /* don't include the rDN */
                if (md.ctr.ctr1.array[i].attid == rdn_sa->attributeID_id) continue;
+
                obj->meta_data_ctr->meta_data[n].originating_change_time = md.ctr.ctr1.array[i].originating_change_time;
                obj->meta_data_ctr->meta_data[n].version = md.ctr.ctr1.array[i].version;
                obj->meta_data_ctr->meta_data[n].originating_invocation_id = md.ctr.ctr1.array[i].originating_invocation_id;
@@ -205,12 +207,10 @@ static WERROR get_nc_changes_build_object(struct drsuapi_DsReplicaObjectListItem
                                         sa->lDAPDisplayName, win_errstr(werr)));
                                return werr;
                        }
-                       /* if DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING is set
+                       /* if DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING is set
                         * check if attribute is secret and send a null value
-                        * TODO: check if we can make this in the database layer
                         */
-                       if ((replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING)
-                           == DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING) {
+                       if (replica_flags & DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING) {
                                drsuapi_process_secret_attribute(&obj->object.attribute_ctr.attributes[i],
                                                                 &obj->meta_data_ctr->meta_data[i]);
                        }
@@ -322,13 +322,14 @@ static WERROR get_nc_changes_udv(struct ldb_context *sam_ctx,
 struct drsuapi_getncchanges_state {
        struct ldb_result *site_res;
        uint32_t num_sent;
-       struct ldb_context *sam_ctx;
        struct ldb_dn *ncRoot_dn;
        uint32_t min_usn;
 };
 
 /* 
   drsuapi_DsGetNCChanges
+
+  see MS-DRSR 4.1.10.5.2 for basic logic of this function
 */
 WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                                     struct drsuapi_DsGetNCChanges *r)
@@ -346,6 +347,8 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
        struct dcesrv_handle *h;
        struct drsuapi_bind_state *b_state;     
        struct drsuapi_getncchanges_state *getnc_state;
+       struct drsuapi_DsGetNCChangesRequest8 *req8;
+       uint32_t options;
 
        DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
        b_state = h->data;
@@ -360,25 +363,43 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
        r->out.ctr->ctr6.more_data = false;
        r->out.ctr->ctr6.uptodateness_vector = NULL;
 
-       /* Check request revision. */
+       /* a RODC doesn't allow for any replication */
+       if (samdb_rodc(ldb_get_opaque(b_state->sam_ctx, "loadparm"))) {
+               DEBUG(0,(__location__ ": DsGetNCChanges attempt on RODC\n"));
+               return WERR_DS_DRA_SOURCE_DISABLED;
+       }
+
+       /* Check request revision. 
+          TODO: Adding mappings to req8 from the other levels
+        */
        if (r->in.level != 8) {
+               DEBUG(0,(__location__ ": Request for DsGetNCChanges with unsupported level %u\n",
+                        r->in.level));
                return WERR_REVISION_MISMATCH;
        }
 
+       req8 = &r->in.req->req8;
+
         /* Perform access checks. */
-       if (r->in.req->req8.naming_context == NULL) {
+       ncRoot = req8->naming_context;
+       if (ncRoot == NULL) {
+               DEBUG(0,(__location__ ": Request for DsGetNCChanges with no NC\n"));
                return WERR_DS_DRA_INVALID_PARAMETER;
        }
 
-       ncRoot = r->in.req->req8.naming_context;
-       if (ncRoot == NULL) {
-               return WERR_DS_DRA_BAD_NC;
+       if (samdb_ntds_options(b_state->sam_ctx, &options) != LDB_SUCCESS) {
+               return WERR_DS_DRA_INTERNAL_ERROR;
+       }
+       
+       if ((options & DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL) &&
+           !(req8->replica_flags & DRSUAPI_DRS_SYNC_FORCED)) {
+               return WERR_DS_DRA_SOURCE_DISABLED;
        }
 
-       if ((r->in.req->req8.replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET)
-           == DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET) {
+
+       if (req8->replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET) {
                /* Ignore the _in_ uptpdateness vector*/
-               r->in.req->req8.uptodateness_vector = NULL;
+               req8->uptodateness_vector = NULL;
        } 
 
        werr = drs_security_level_check(dce_call, "DsGetNCChanges");
@@ -393,18 +414,6 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
                        return WERR_NOMEM;
                }
                b_state->getncchanges_state = getnc_state;
-
-
-               /*
-                * connect to the samdb. TODO: We need to check that the caller
-                * has the rights to do this. This exposes all attributes,
-                * including all passwords.
-                */
-               getnc_state->sam_ctx = samdb_connect(getnc_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, 
-                                                    system_session(getnc_state, dce_call->conn->dce_ctx->lp_ctx));
-               if (!getnc_state->sam_ctx) {
-                       return WERR_FOOBAR;
-               }
        }
 
        /* we need the session key for encrypting password attributes */
@@ -414,41 +423,65 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
                return WERR_DS_DRA_INTERNAL_ERROR;              
        }
 
+       /* we don't yet support extended operations */
+       if (req8->extended_op != DRSUAPI_EXOP_NONE) {
+               DEBUG(0,(__location__ ": Request for DsGetNCChanges extended op 0x%x\n",
+                        (unsigned)req8->extended_op));
+               return WERR_DS_DRA_NOT_SUPPORTED;
+       }
+
+       /* 
+          TODO: MS-DRSR section 4.1.10.1.1
+          Work out if this is the start of a new cycle */
+
        if (getnc_state->site_res == NULL) {
                char* search_filter;
                enum ldb_scope scope = LDB_SCOPE_SUBTREE;
 
-               getnc_state->min_usn = r->in.req->req8.highwatermark.highest_usn;
+               getnc_state->min_usn = req8->highwatermark.highest_usn;
 
                /* Construct response. */
                search_filter = talloc_asprintf(mem_ctx,
                                                "(uSNChanged>=%llu)",
                                                (unsigned long long)(getnc_state->min_usn+1));
-               
-               if (r->in.req->req8.replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY) {
+       
+               if (req8->replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY) {
                        search_filter = talloc_asprintf(mem_ctx,
                                                        "(&%s(isCriticalSystemObject=TRUE))",
                                                        search_filter);
                }
                
-               getnc_state->ncRoot_dn = ldb_dn_new(getnc_state, getnc_state->sam_ctx, ncRoot->dn);
-               if (r->in.req->req8.replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP) {
+               getnc_state->ncRoot_dn = ldb_dn_new(getnc_state, b_state->sam_ctx, ncRoot->dn);
+               if (req8->replica_flags & DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP) {
                        scope = LDB_SCOPE_BASE;
                }
                
                DEBUG(6,(__location__ ": getncchanges on %s using filter %s\n",
                         ldb_dn_get_linearized(getnc_state->ncRoot_dn), search_filter));
-               ret = drsuapi_search_with_extended_dn(getnc_state->sam_ctx, getnc_state, &getnc_state->site_res,
+               ret = drsuapi_search_with_extended_dn(b_state->sam_ctx, getnc_state, &getnc_state->site_res,
                                                      getnc_state->ncRoot_dn, scope, attrs,
-                                                     "distinguishedName",
+                                                     "uSNChanged",
                                                      search_filter);
                if (ret != LDB_SUCCESS) {
                        return WERR_DS_DRA_INTERNAL_ERROR;
                }
+       } else {
+               /* check that this request is for the same NC as the previous one */
+               struct ldb_dn *dn;
+               dn = ldb_dn_new(getnc_state, b_state->sam_ctx, ncRoot->dn);
+               if (!dn) {
+                       return WERR_NOMEM;
+               }
+               if (ldb_dn_compare(dn, getnc_state->ncRoot_dn) != 0) {
+                       DEBUG(0,(__location__ ": DsGetNCChanges 2nd replication on different DN %s %s\n",
+                                ldb_dn_get_linearized(dn),
+                                ldb_dn_get_linearized(getnc_state->ncRoot_dn)));
+                       return WERR_DS_DRA_BAD_NC;
+               }
        }
 
        /* Prefix mapping */
-       schema = dsdb_get_schema(getnc_state->sam_ctx);
+       schema = dsdb_get_schema(b_state->sam_ctx);
        if (!schema) {
                DEBUG(0,("No schema in sam_ctx\n"));
                return WERR_DS_DRA_INTERNAL_ERROR;
@@ -457,7 +490,7 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
        r->out.ctr->ctr6.naming_context = talloc(mem_ctx, struct drsuapi_DsReplicaObjectIdentifier);
        *r->out.ctr->ctr6.naming_context = *ncRoot;
 
-       if (dsdb_find_guid_by_dn(getnc_state->sam_ctx, getnc_state->ncRoot_dn, 
+       if (dsdb_find_guid_by_dn(b_state->sam_ctx, getnc_state->ncRoot_dn, 
                                 &r->out.ctr->ctr6.naming_context->guid) != LDB_SUCCESS) {
                DEBUG(0,(__location__ ": Failed to find GUID of ncRoot_dn %s\n",
                         ldb_dn_get_linearized(getnc_state->ncRoot_dn)));
@@ -465,23 +498,23 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
        }
 
        /* find the SID if there is one */
-       dsdb_find_sid_by_dn(getnc_state->sam_ctx, getnc_state->ncRoot_dn, &r->out.ctr->ctr6.naming_context->sid);
+       dsdb_find_sid_by_dn(b_state->sam_ctx, getnc_state->ncRoot_dn, &r->out.ctr->ctr6.naming_context->sid);
 
        dsdb_get_oid_mappings_drsuapi(schema, true, mem_ctx, &ctr);
        r->out.ctr->ctr6.mapping_ctr = *ctr;
 
-       r->out.ctr->ctr6.source_dsa_guid = *(samdb_ntds_objectGUID(getnc_state->sam_ctx));
-       r->out.ctr->ctr6.source_dsa_invocation_id = *(samdb_ntds_invocation_id(getnc_state->sam_ctx));
+       r->out.ctr->ctr6.source_dsa_guid = *(samdb_ntds_objectGUID(b_state->sam_ctx));
+       r->out.ctr->ctr6.source_dsa_invocation_id = *(samdb_ntds_invocation_id(b_state->sam_ctx));
 
-       r->out.ctr->ctr6.old_highwatermark = r->in.req->req8.highwatermark;
-       r->out.ctr->ctr6.new_highwatermark = r->in.req->req8.highwatermark;
+       r->out.ctr->ctr6.old_highwatermark = req8->highwatermark;
+       r->out.ctr->ctr6.new_highwatermark = req8->highwatermark;
 
        r->out.ctr->ctr6.first_object = NULL;
        currentObject = &r->out.ctr->ctr6.first_object;
 
        for(i=getnc_state->num_sent; 
            i<getnc_state->site_res->count && 
-                   (r->out.ctr->ctr6.object_count < r->in.req->req8.max_object_count);
+                   (r->out.ctr->ctr6.object_count < req8->max_object_count);
            i++) {
                int uSN;
                struct drsuapi_DsReplicaObjectListItemEx *obj;
@@ -493,9 +526,9 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
                }
 
                werr = get_nc_changes_build_object(obj, getnc_state->site_res->msgs[i], 
-                                                  getnc_state->sam_ctx, getnc_state->ncRoot_dn, 
+                                                  b_state->sam_ctx, getnc_state->ncRoot_dn, 
                                                   schema, &session_key, getnc_state->min_usn,
-                                                  r->in.req->req8.replica_flags);
+                                                  req8->replica_flags);
                if (!W_ERROR_IS_OK(werr)) {
                        return werr;
                }
@@ -518,6 +551,29 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
 
        r->out.ctr->ctr6.nc_object_count = getnc_state->site_res->count;
 
+       /* the client can us to call UpdateRefs on its behalf to
+          re-establish monitoring of the NC */
+       if ((req8->replica_flags & DRSUAPI_DRS_ADD_REF) && 
+           !GUID_all_zero(&req8->destination_dsa_guid)) {
+               struct drsuapi_DsReplicaUpdateRefsRequest1 ureq;
+               ureq.naming_context = ncRoot;
+               ureq.dest_dsa_dns_name = talloc_asprintf(mem_ctx, "%s._msdcs.%s",
+                                                        GUID_string(mem_ctx, &req8->destination_dsa_guid),
+                                                        lp_realm(dce_call->conn->dce_ctx->lp_ctx));
+               if (!ureq.dest_dsa_dns_name) {
+                       return WERR_NOMEM;
+               }
+               ureq.dest_dsa_guid = req8->destination_dsa_guid;
+               ureq.options = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE |
+                       DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION |
+                       DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK;
+               werr = drsuapi_UpdateRefs(b_state, mem_ctx, &ureq);
+               if (!W_ERROR_IS_OK(werr)) {
+                       DEBUG(0,(__location__ ": Failed UpdateRefs in DsGetNCChanges - %s\n",
+                                win_errstr(werr)));
+               }
+       }
+
        if (i < getnc_state->site_res->count) {
                r->out.ctr->ctr6.more_data = true;
        } else {
@@ -528,7 +584,7 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
 
                r->out.ctr->ctr6.new_highwatermark.highest_usn = r->out.ctr->ctr6.new_highwatermark.tmp_highest_usn;
 
-               werr = get_nc_changes_udv(getnc_state->sam_ctx, getnc_state->ncRoot_dn, 
+               werr = get_nc_changes_udv(b_state->sam_ctx, getnc_state->ncRoot_dn, 
                                          r->out.ctr->ctr6.uptodateness_vector);
                if (!W_ERROR_IS_OK(werr)) {
                        return werr;
@@ -538,8 +594,9 @@ WERROR dcesrv_drsuapi_DsGetNCChanges(struct dcesrv_call_state *dce_call, TALLOC_
                b_state->getncchanges_state = NULL;
        }
 
-       DEBUG(3,("DsGetNCChanges with uSNChanged >= %llu on %s gave %u objects\n", 
-                (unsigned long long)(r->in.req->req8.highwatermark.highest_usn+1),
+       DEBUG(2,("DsGetNCChanges with uSNChanged >= %llu flags 0x%08x on %s gave %u objects\n", 
+                (unsigned long long)(req8->highwatermark.highest_usn+1),
+                req8->replica_flags,
                 ncRoot->dn, r->out.ctr->ctr6.object_count));
 
        return WERR_OK;

diff --git a/source4/rpc_server/drsuapi/updaterefs.c b/source4/rpc_server/drsuapi/updaterefs.c
index e12be6f05875b945b05d45efb3a12039533c0b44..60a70c5032c36ff23f4b1c9673f5d9b9e0d12493 100644 (file)
--- a/source4/rpc_server/drsuapi/updaterefs.c
+++ b/source4/rpc_server/drsuapi/updaterefs.c
@@ -35,16 +35,29 @@ struct repsTo {
   add a replication destination for a given partition GUID
  */
 static WERROR uref_add_dest(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx, 
-                           struct ldb_dn *dn, struct repsFromTo1 *dest)
+                           struct ldb_dn *dn, struct repsFromTo1 *dest, 
+                           uint32_t options)
 {
        struct repsTo reps;
        WERROR werr;
+       int i;
 
        werr = dsdb_loadreps(sam_ctx, mem_ctx, dn, "repsTo", &reps.r, &reps.count);
        if (!W_ERROR_IS_OK(werr)) {
                return werr;
        }
 
+       for (i=0; i<reps.count; i++) {
+               if (GUID_compare(&dest->source_dsa_obj_guid, 
+                                &reps.r[i].ctr.ctr1.source_dsa_obj_guid) == 0) {
+                       if (options & DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK) {
+                               return WERR_OK;
+                       } else {
+                               return WERR_DS_DRA_REF_ALREADY_EXISTS;
+                       }
+               }
+       }
+
        reps.r = talloc_realloc(mem_ctx, reps.r, struct repsFromToBlob, reps.count+1);
        if (reps.r == NULL) {
                return WERR_DS_DRA_INTERNAL_ERROR;
@@ -66,11 +79,13 @@ static WERROR uref_add_dest(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
   delete a replication destination for a given partition GUID
  */
 static WERROR uref_del_dest(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx, 
-                           struct ldb_dn *dn, struct GUID *dest_guid)
+                           struct ldb_dn *dn, struct GUID *dest_guid, 
+                           uint32_t options)
 {
        struct repsTo reps;
        WERROR werr;
        int i;
+       bool found = false;
 
        werr = dsdb_loadreps(sam_ctx, mem_ctx, dn, "repsTo", &reps.r, &reps.count);
        if (!W_ERROR_IS_OK(werr)) {
@@ -83,6 +98,7 @@ static WERROR uref_del_dest(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
                                memmove(&reps.r[i], &reps.r[i+1], sizeof(reps.r[i])*(reps.count-(i+1)));
                        }
                        reps.count--;
+                       found = true;
                }
        }
 
@@ -91,60 +107,42 @@ static WERROR uref_del_dest(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
                return werr;
        }
 
+       if (!found && !(options & DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK)) {
+               return WERR_DS_DRA_REF_NOT_FOUND;
+       }
+
        return WERR_OK; 
 }
 
 /* 
-  drsuapi_DsReplicaUpdateRefs
+  drsuapi_DsReplicaUpdateRefs - a non RPC version callable from getncchanges
 */
-WERROR dcesrv_drsuapi_DsReplicaUpdateRefs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
-                                         struct drsuapi_DsReplicaUpdateRefs *r)
+WERROR drsuapi_UpdateRefs(struct drsuapi_bind_state *b_state, TALLOC_CTX *mem_ctx,
+                         struct drsuapi_DsReplicaUpdateRefsRequest1 *req)
 {
-       struct drsuapi_DsReplicaUpdateRefsRequest1 *req;
-       struct ldb_context *sam_ctx;
        WERROR werr;
        struct ldb_dn *dn;
 
-       werr = drs_security_level_check(dce_call, "DsReplicaUpdateRefs");
-       if (!W_ERROR_IS_OK(werr)) {
-               return werr;
-       }
-
-       if (r->in.level != 1) {
-               DEBUG(0,("DrReplicUpdateRefs - unsupported level %u\n", r->in.level));
-               return WERR_DS_DRA_INVALID_PARAMETER;
-       }
-
-       req = &r->in.req.req1;
        DEBUG(4,("DsReplicaUpdateRefs for host '%s' with GUID %s options 0x%08x nc=%s\n",
                 req->dest_dsa_dns_name, GUID_string(mem_ctx, &req->dest_dsa_guid),
                 req->options,
                 drs_ObjectIdentifier_to_string(mem_ctx, req->naming_context)));
 
-       /* TODO: We need to authenticate this operation pretty carefully */
-       sam_ctx = samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, 
-                               system_session(mem_ctx, dce_call->conn->dce_ctx->lp_ctx));
-       if (!sam_ctx) {
-               return WERR_DS_DRA_INTERNAL_ERROR;              
-       }
-
-       dn = ldb_dn_new(mem_ctx, sam_ctx, req->naming_context->dn);
+       dn = ldb_dn_new(mem_ctx, b_state->sam_ctx, req->naming_context->dn);
        if (dn == NULL) {
-               talloc_free(sam_ctx);           
                return WERR_DS_INVALID_DN_SYNTAX;
        }
 
-       if (ldb_transaction_start(sam_ctx) != LDB_SUCCESS) {
+       if (ldb_transaction_start(b_state->sam_ctx) != LDB_SUCCESS) {
                DEBUG(0,(__location__ ": Failed to start transaction on samdb\n"));
-               talloc_free(sam_ctx);
                return WERR_DS_DRA_INTERNAL_ERROR;              
        }
 
        if (req->options & DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE) {
-               werr = uref_del_dest(sam_ctx, mem_ctx, dn, &req->dest_dsa_guid);
+               werr = uref_del_dest(b_state->sam_ctx, mem_ctx, dn, &req->dest_dsa_guid, req->options);
                if (!W_ERROR_IS_OK(werr)) {
                        DEBUG(0,("Failed to delete repsTo for %s\n",
-                                GUID_string(dce_call, &req->dest_dsa_guid)));
+                                GUID_string(mem_ctx, &req->dest_dsa_guid)));
                        goto failed;
                }
        }
@@ -161,24 +159,53 @@ WERROR dcesrv_drsuapi_DsReplicaUpdateRefs(struct dcesrv_call_state *dce_call, TA
                dest.source_dsa_obj_guid = req->dest_dsa_guid;
                dest.replica_flags       = req->options;
 
-               werr = uref_add_dest(sam_ctx, mem_ctx, dn, &dest);
+               werr = uref_add_dest(b_state->sam_ctx, mem_ctx, dn, &dest, req->options);
                if (!W_ERROR_IS_OK(werr)) {
-                       DEBUG(0,("Failed to delete repsTo for %s\n",
-                                GUID_string(dce_call, &dest.source_dsa_obj_guid)));
+                       DEBUG(0,("Failed to add repsTo for %s\n",
+                                GUID_string(mem_ctx, &dest.source_dsa_obj_guid)));
                        goto failed;
                }
        }
 
-       if (ldb_transaction_commit(sam_ctx) != LDB_SUCCESS) {
+       if (ldb_transaction_commit(b_state->sam_ctx) != LDB_SUCCESS) {
                DEBUG(0,(__location__ ": Failed to commit transaction on samdb\n"));
                return WERR_DS_DRA_INTERNAL_ERROR;              
        }
 
-       talloc_free(sam_ctx);
        return WERR_OK;
 
 failed:
-       ldb_transaction_cancel(sam_ctx);
-       talloc_free(sam_ctx);
+       ldb_transaction_cancel(b_state->sam_ctx);
        return werr;
 }
+
+/* 
+  drsuapi_DsReplicaUpdateRefs
+*/
+WERROR dcesrv_drsuapi_DsReplicaUpdateRefs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                         struct drsuapi_DsReplicaUpdateRefs *r)
+{
+       struct dcesrv_handle *h;
+       struct drsuapi_bind_state *b_state;
+       struct drsuapi_DsReplicaUpdateRefsRequest1 *req;
+       WERROR werr;
+
+       DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
+       b_state = h->data;
+
+       werr = drs_security_level_check(dce_call, "DsReplicaUpdateRefs");
+       if (!W_ERROR_IS_OK(werr)) {
+               return werr;
+       }
+
+       if (r->in.level != 1) {
+               DEBUG(0,("DrReplicUpdateRefs - unsupported level %u\n", r->in.level));
+               return WERR_DS_DRA_INVALID_PARAMETER;
+       }
+
+       req = &r->in.req.req1;
+
+       return drsuapi_UpdateRefs(b_state, mem_ctx, req);
+}
+
+

diff --git a/source4/rpc_server/lsa/dcesrv_lsa.c b/source4/rpc_server/lsa/dcesrv_lsa.c
index 3d6352af46b98998fb78389257123a3852e24c7f..0e6a55ec2f5df42d6c948179e58c1161a0ad0d5b 100644 (file)
--- a/source4/rpc_server/lsa/dcesrv_lsa.c
+++ b/source4/rpc_server/lsa/dcesrv_lsa.c
@@ -80,7 +80,7 @@ static NTSTATUS dcesrv_build_lsa_sd(TALLOC_CTX *mem_ctx,
        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 
        status = dom_sid_split_rid(tmp_ctx, sid, &domain_sid, &rid);
-       NT_STATUS_NOT_OK_RETURN(status);
+       NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
 
        domain_admins_sid = dom_sid_add_rid(tmp_ctx, domain_sid, DOMAIN_RID_ADMINS);
        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(domain_admins_sid, tmp_ctx);
@@ -694,7 +694,7 @@ static NTSTATUS dcesrv_lsa_EnumAccounts(struct dcesrv_call_state *dce_call, TALL
        /* NOTE: This call must only return accounts that have at least
           one privilege set 
        */
-       ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs, 
+       ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs, 
                           "(&(objectSid=*)(privilege=*))");
        if (ret < 0) {
                return NT_STATUS_NO_SUCH_USER;
@@ -1830,7 +1830,7 @@ static NTSTATUS dcesrv_lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call,
                return NT_STATUS_NO_MEMORY;
        }
 
-       ret = gendb_search(astate->policy->sam_ldb, mem_ctx, NULL, &res, attrs, 
+       ret = gendb_search(astate->policy->pdb, mem_ctx, NULL, &res, attrs, 
                           "objectSid=%s", sidstr);
        if (ret != 1) {
                return NT_STATUS_OK;
@@ -1886,7 +1886,7 @@ static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
                return NT_STATUS_NO_MEMORY;
        }
 
-       ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs, 
+       ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs, 
                           "(&(objectSid=%s)(privilege=*))", sidstr);
        if (ret == 0) {
                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
@@ -1897,7 +1897,7 @@ static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
        if (ret == -1) {
                DEBUG(3, ("searching for account rights for SID: %s failed: %s", 
                          dom_sid_string(mem_ctx, r->in.sid),
-                         ldb_errstring(state->sam_ldb)));
+                         ldb_errstring(state->pdb)));
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
 
@@ -1932,15 +1932,17 @@ static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_
                                           struct dom_sid *sid,
                                           const struct lsa_RightSet *rights)
 {
-       const char *sidstr;
+       const char *sidstr, *sidndrstr;
        struct ldb_message *msg;
        struct ldb_message_element *el;
        int i, ret;
        struct lsa_EnumAccountRights r2;
+       char *dnstr;
 
-       sidstr = ldap_encode_ndr_dom_sid(mem_ctx, sid);
-       if (sidstr == NULL) {
-               return NT_STATUS_NO_MEMORY;
+       if (security_session_user_level(dce_call->conn->auth_state.session_info) < 
+           SECURITY_ADMINISTRATOR) {
+               DEBUG(0,("lsa_AddRemoveAccount refused for supplied security token\n"));
+               return NT_STATUS_ACCESS_DENIED;
        }
 
        msg = ldb_msg_new(mem_ctx);
@@ -1948,24 +1950,17 @@ static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_
                return NT_STATUS_NO_MEMORY;
        }
 
-       msg->dn = samdb_search_dn(state->sam_ldb, mem_ctx, 
-                                 NULL, "objectSid=%s", sidstr);
-       if (msg->dn == NULL) {
-               NTSTATUS status;
-               if (ldb_flag == LDB_FLAG_MOD_DELETE) {
-                       return NT_STATUS_OBJECT_NAME_NOT_FOUND;
-               }
-               status = samdb_create_foreign_security_principal(state->sam_ldb, mem_ctx, 
-                                                                sid, &msg->dn);
-               if (!NT_STATUS_IS_OK(status)) {
-                       return status;
-               }
-               return NT_STATUS_NO_SUCH_USER;
-       }
+       sidndrstr = ldap_encode_ndr_dom_sid(msg, sid);
+       NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sidndrstr, msg);
 
-       if (ldb_msg_add_empty(msg, "privilege", ldb_flag, NULL)) {
-               return NT_STATUS_NO_MEMORY;
-       }
+       sidstr = dom_sid_string(msg, sid);
+       NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sidstr, msg);
+
+       dnstr = talloc_asprintf(msg, "sid=%s", sidstr);
+       NT_STATUS_HAVE_NO_MEMORY_AND_FREE(dnstr, msg);
+
+       msg->dn = ldb_dn_new(msg, state->pdb, dnstr);
+       NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg->dn, msg);
 
        if (ldb_flag == LDB_FLAG_MOD_ADD) {
                NTSTATUS status;
@@ -1982,6 +1977,7 @@ static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_
 
        for (i=0;i<rights->count;i++) {
                if (sec_privilege_id(rights->names[i].string) == -1) {
+                       talloc_free(msg);
                        return NT_STATUS_NO_SUCH_PRIVILEGE;
                }
 
@@ -1998,26 +1994,41 @@ static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_
 
                ret = ldb_msg_add_string(msg, "privilege", rights->names[i].string);
                if (ret != LDB_SUCCESS) {
+                       talloc_free(msg);
                        return NT_STATUS_NO_MEMORY;
                }
        }
 
        el = ldb_msg_find_element(msg, "privilege");
        if (!el) {
+               talloc_free(msg);
                return NT_STATUS_OK;
        }
 
-       ret = ldb_modify(state->sam_ldb, msg);
+       el->flags = ldb_flag;
+
+       ret = ldb_modify(state->pdb, msg);
+       if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+               if (samdb_msg_add_dom_sid(state->pdb, msg, msg, "objectSid", sid) != LDB_SUCCESS) {
+                       talloc_free(msg);
+                       return NT_STATUS_NO_MEMORY;
+               }
+               samdb_msg_add_string(state->pdb, msg, msg, "comment", "added via LSA");
+               ret = ldb_add(state->pdb, msg);         
+       }
        if (ret != 0) {
                if (ldb_flag == LDB_FLAG_MOD_DELETE && ret == LDB_ERR_NO_SUCH_ATTRIBUTE) {
-                       return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                       talloc_free(msg);
+                       return NT_STATUS_OK;
                }
                DEBUG(3, ("Could not %s attributes from %s: %s", 
                          ldb_flag == LDB_FLAG_MOD_DELETE ? "delete" : "add",
-                         ldb_dn_get_linearized(msg->dn), ldb_errstring(state->sam_ldb)));
+                         ldb_dn_get_linearized(msg->dn), ldb_errstring(state->pdb)));
+               talloc_free(msg);
                return NT_STATUS_UNEXPECTED_IO_ERROR;
        }
 
+       talloc_free(msg);
        return NT_STATUS_OK;
 }
 
@@ -2880,7 +2891,7 @@ static NTSTATUS dcesrv_lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *d
                return NT_STATUS_NO_SUCH_PRIVILEGE;
        }
 
-       ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs, 
+       ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs, 
                           "privilege=%s", privname);
        if (ret == -1) {
                return NT_STATUS_INTERNAL_DB_CORRUPTION;

diff --git a/source4/rpc_server/lsa/lsa.h b/source4/rpc_server/lsa/lsa.h
index ffdf96d091bb3c07343c24c53913618be004b229..53fe1026303c34c885248072e243f8cdb1977330 100644 (file)
--- a/source4/rpc_server/lsa/lsa.h
+++ b/source4/rpc_server/lsa/lsa.h
@@ -40,6 +40,7 @@
 struct lsa_policy_state {
        struct dcesrv_handle *handle;
        struct ldb_context *sam_ldb;
+       struct ldb_context *pdb;
        uint32_t access_mask;
        struct ldb_dn *domain_dn;
        struct ldb_dn *forest_dn;

diff --git a/source4/rpc_server/lsa/lsa_init.c b/source4/rpc_server/lsa/lsa_init.c
index ae565a3ff16df0ff7c64ba0a9296b09d30fcfe35..dd7d46b41daad66082982713e0e6fce45cc3d169 100644 (file)
--- a/source4/rpc_server/lsa/lsa_init.c
+++ b/source4/rpc_server/lsa/lsa_init.c
@@ -21,6 +21,7 @@
 */
 
 #include "rpc_server/lsa/lsa.h"
+#include "dsdb/samdb/samdb_proto.h"
 
 NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                                     struct lsa_policy_state **_state)
@@ -48,6 +49,12 @@ NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_
                return NT_STATUS_INVALID_SYSTEM_SERVICE;
        }
 
+       /* and the privilege database */
+       state->pdb = privilege_connect(state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx);
+       if (state->pdb == NULL) {
+               return NT_STATUS_INVALID_SYSTEM_SERVICE;
+       }
+
        /* work out the domain_dn - useful for so many calls its worth
           fetching here */
        state->domain_dn = ldb_get_default_basedn(state->sam_ldb);

diff --git a/source4/rpc_server/netlogon/dcerpc_netlogon.c b/source4/rpc_server/netlogon/dcerpc_netlogon.c
index 1a45711c574cdeb12c7ccc6c333ad9914c41a901..f763069a3b5d84a26a66e74c1c9dae050d701fad 100644 (file)
--- a/source4/rpc_server/netlogon/dcerpc_netlogon.c
+++ b/source4/rpc_server/netlogon/dcerpc_netlogon.c
@@ -643,7 +643,7 @@ static NTSTATUS dcesrv_netr_LogonSamLogon_base(struct dcesrv_call_state *dce_cal
                sam6 = talloc_zero(mem_ctx, struct netr_SamInfo6);
                NT_STATUS_HAVE_NO_MEMORY(sam6);
                sam6->base = *sam;
-               sam6->forest.string = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
+               sam6->forest.string = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
                sam6->principle.string = talloc_asprintf(mem_ctx, "%s@%s", 
                                                         sam->account_name.string, sam6->forest.string);
                NT_STATUS_HAVE_NO_MEMORY(sam6->principle.string);
@@ -1096,7 +1096,7 @@ static NTSTATUS fill_one_domain_info(TALLOC_CTX *mem_ctx,
 
        if (is_local) {
                info->domainname.string = lp_sam_name(lp_ctx);
-               info->dns_domainname.string = lp_realm(lp_ctx);
+               info->dns_domainname.string = lp_dnsdomain(lp_ctx);
                info->domain_guid = samdb_result_guid(res, "objectGUID");
                info->domain_sid = samdb_result_dom_sid(mem_ctx, res, "objectSid");
        } else {
@@ -1432,15 +1432,15 @@ static WERROR dcesrv_netr_DsRGetDCNameEx2(struct dcesrv_call_state *dce_call, TA
         */
        info->dc_unc                    = talloc_asprintf(mem_ctx, "\\\\%s.%s",
                                                          lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx), 
-                                                         lp_realm(dce_call->conn->dce_ctx->lp_ctx));
+                                                         lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx));
        W_ERROR_HAVE_NO_MEMORY(info->dc_unc);
        info->dc_address                = talloc_strdup(mem_ctx, "\\\\0.0.0.0");
        W_ERROR_HAVE_NO_MEMORY(info->dc_address);
        info->dc_address_type           = DS_ADDRESS_TYPE_INET;
        info->domain_guid               = samdb_result_guid(res[0], "objectGUID");
-       info->domain_name               = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
-       info->forest_name               = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
-       info->dc_flags                  = DS_DNS_FOREST |
+       info->domain_name               = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
+       info->forest_name               = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
+       info->dc_flags                  = DS_DNS_FOREST_ROOT |
                                          DS_DNS_DOMAIN |
                                          DS_DNS_CONTROLLER |
                                          DS_SERVER_WRITABLE |
@@ -1614,7 +1614,7 @@ static WERROR dcesrv_netr_DsrEnumerateDomainTrusts(struct dcesrv_call_state *dce
        /* TODO: add filtering by trust_flags, and correct trust_type
           and attributes */
        trusts->array[0].netbios_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
-       trusts->array[0].dns_name     = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
+       trusts->array[0].dns_name     = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
        trusts->array[0].trust_flags =
                NETR_TRUST_FLAG_TREEROOT | 
                NETR_TRUST_FLAG_IN_FOREST | 

diff --git a/source4/rpc_server/samr/dcesrv_samr.c b/source4/rpc_server/samr/dcesrv_samr.c
index 6dda06a6b88fd8b0d1fc434b976fa69342d7e411..6c5f5b845f8bcf6a3c7861d61f08297736cbc8e8 100644 (file)
--- a/source4/rpc_server/samr/dcesrv_samr.c
+++ b/source4/rpc_server/samr/dcesrv_samr.c
@@ -949,7 +949,7 @@ static NTSTATUS dcesrv_samr_SetDomainInfo(struct dcesrv_call_state *dce_call, TA
 
        /* modify the samdb record */
        ret = ldb_modify(sam_ctx, msg);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                DEBUG(1,("Failed to modify record %s: %s\n",
                         ldb_dn_get_linearized(d_state->domain_dn),
                         ldb_errstring(sam_ctx)));
@@ -1234,7 +1234,7 @@ static NTSTATUS dcesrv_samr_CreateUser2(struct dcesrv_call_state *dce_call, TALL
         */
 
        ret = ldb_transaction_start(d_state->sam_ctx);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                DEBUG(0,("Failed to start a transaction for user creation: %s\n",
                         ldb_errstring(d_state->sam_ctx)));
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
@@ -1389,7 +1389,7 @@ static NTSTATUS dcesrv_samr_CreateUser2(struct dcesrv_call_state *dce_call, TALL
 
        /* modify the samdb record */
        ret = samdb_replace(a_state->sam_ctx, mem_ctx, msg);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                DEBUG(0,("Failed to modify account record %s to set userAccountControl: %s\n",
                         ldb_dn_get_linearized(msg->dn),
                         ldb_errstring(d_state->sam_ctx)));
@@ -1400,7 +1400,7 @@ static NTSTATUS dcesrv_samr_CreateUser2(struct dcesrv_call_state *dce_call, TALL
        }
 
        ret = ldb_transaction_commit(d_state->sam_ctx);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                DEBUG(0,("Failed to commit transaction to add and modify account record %s: %s\n",
                         ldb_dn_get_linearized(msg->dn),
                         ldb_errstring(d_state->sam_ctx)));
@@ -2193,7 +2193,7 @@ static NTSTATUS dcesrv_samr_SetGroupInfo(struct dcesrv_call_state *dce_call, TAL
 
        /* modify the samdb record */
        ret = ldb_modify(g_state->sam_ctx, msg);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                /* we really need samdb.c to return NTSTATUS */
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -2224,8 +2224,9 @@ static NTSTATUS dcesrv_samr_AddGroupMember(struct dcesrv_call_state *dce_call, T
        d_state = a_state->domain_state;
 
        membersid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
-       if (membersid == NULL)
+       if (membersid == NULL) {
                return NT_STATUS_NO_MEMORY;
+       }
 
        /* In native mode, AD can also nest domain groups. Not sure yet
         * whether this is also available via RPC. */
@@ -2234,7 +2235,7 @@ static NTSTATUS dcesrv_samr_AddGroupMember(struct dcesrv_call_state *dce_call, T
                                 "(&(objectSid=%s)(objectclass=user))",
                                 ldap_encode_ndr_dom_sid(mem_ctx, membersid));
 
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
 
@@ -2258,9 +2259,11 @@ static NTSTATUS dcesrv_samr_AddGroupMember(struct dcesrv_call_state *dce_call, T
 
        mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
 
-       if (samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
-                                memberdn) != 0)
+       ret = samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
+                                                               memberdn);
+       if (ret != LDB_SUCCESS) {
                return NT_STATUS_UNSUCCESSFUL;
+       }
 
        ret = ldb_modify(a_state->sam_ctx, mod);
        switch (ret) {
@@ -2273,7 +2276,6 @@ static NTSTATUS dcesrv_samr_AddGroupMember(struct dcesrv_call_state *dce_call, T
        default:
                return NT_STATUS_UNSUCCESSFUL;
        }
-
 }
 
 
@@ -2294,7 +2296,7 @@ static NTSTATUS dcesrv_samr_DeleteDomainGroup(struct dcesrv_call_state *dce_call
        a_state = h->data;
 
        ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                return NT_STATUS_UNSUCCESSFUL;
        }
 
@@ -2336,7 +2338,7 @@ static NTSTATUS dcesrv_samr_DeleteGroupMember(struct dcesrv_call_state *dce_call
                                 "(&(objectSid=%s)(objectclass=user))",
                                 ldap_encode_ndr_dom_sid(mem_ctx, membersid));
 
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
 
@@ -2360,8 +2362,9 @@ static NTSTATUS dcesrv_samr_DeleteGroupMember(struct dcesrv_call_state *dce_call
 
        mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
 
-       if (samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
-                                memberdn) != 0) {
+       ret = samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
+                                                               memberdn);
+       if (ret != LDB_SUCCESS) {
                return NT_STATUS_NO_MEMORY;
        }
 
@@ -2643,7 +2646,7 @@ static NTSTATUS dcesrv_samr_SetAliasInfo(struct dcesrv_call_state *dce_call, TAL
 
        /* modify the samdb record */
        ret = ldb_modify(a_state->sam_ctx, msg);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                /* we really need samdb.c to return NTSTATUS */
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -2732,12 +2735,15 @@ static NTSTATUS dcesrv_samr_AddAliasMember(struct dcesrv_call_state *dce_call, T
 
        mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
 
-       if (samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
-                                ldb_dn_alloc_linearized(mem_ctx, memberdn)) != 0)
+       ret = samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
+                                ldb_dn_alloc_linearized(mem_ctx, memberdn));
+       if (ret != LDB_SUCCESS) {
                return NT_STATUS_UNSUCCESSFUL;
+       }
 
-       if (ldb_modify(a_state->sam_ctx, mod) != 0)
+       if (ldb_modify(a_state->sam_ctx, mod) != LDB_SUCCESS) {
                return NT_STATUS_UNSUCCESSFUL;
+       }
 
        return NT_STATUS_OK;
 }
@@ -2754,6 +2760,7 @@ static NTSTATUS dcesrv_samr_DeleteAliasMember(struct dcesrv_call_state *dce_call
        struct samr_domain_state *d_state;
        struct ldb_message *mod;
        const char *memberdn;
+       int ret;
 
        DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
 
@@ -2774,11 +2781,12 @@ static NTSTATUS dcesrv_samr_DeleteAliasMember(struct dcesrv_call_state *dce_call
 
        mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
 
-       if (samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
-                                memberdn) != 0)
+       ret = samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
+                                                                memberdn);
+       if (ret != LDB_SUCCESS)
                return NT_STATUS_UNSUCCESSFUL;
 
-       if (ldb_modify(a_state->sam_ctx, mod) != 0)
+       if (ldb_modify(a_state->sam_ctx, mod) != LDB_SUCCESS)
                return NT_STATUS_UNSUCCESSFUL;
 
        return NT_STATUS_OK;
@@ -2947,7 +2955,7 @@ static NTSTATUS dcesrv_samr_DeleteUser(struct dcesrv_call_state *dce_call, TALLO
        a_state = h->data;
 
        ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
-       if (ret != 0) {
+       if (ret != LDB_SUCCESS) {
                DEBUG(1, ("Failed to delete user: %s: %s\n", 
                          ldb_dn_get_linearized(a_state->account_dn), 
                          ldb_errstring(a_state->sam_ctx)));
@@ -3603,14 +3611,16 @@ static NTSTATUS dcesrv_samr_SetUserInfo(struct dcesrv_call_state *dce_call, TALL
        }
 
        /* modify the samdb record */
-       ret = ldb_modify(a_state->sam_ctx, msg);
-       if (ret != 0) {
-               DEBUG(1,("Failed to modify record %s: %s\n",
-                        ldb_dn_get_linearized(a_state->account_dn),
-                        ldb_errstring(a_state->sam_ctx)));
-
-               /* we really need samdb.c to return NTSTATUS */
-               return NT_STATUS_UNSUCCESSFUL;
+       if (msg->num_elements > 0) {
+               ret = ldb_modify(a_state->sam_ctx, msg);
+               if (ret != LDB_SUCCESS) {
+                       DEBUG(1,("Failed to modify record %s: %s\n",
+                                ldb_dn_get_linearized(a_state->account_dn),
+                                ldb_errstring(a_state->sam_ctx)));
+
+                       /* we really need samdb.c to return NTSTATUS */
+                       return NT_STATUS_UNSUCCESSFUL;
+               }
        }
 
        return NT_STATUS_OK;
@@ -4175,10 +4185,14 @@ static NTSTATUS dcesrv_samr_GetDomPwInfo(struct dcesrv_call_state *dce_call, TAL
        ret = gendb_search_dn(sam_ctx, 
                           mem_ctx, NULL, &msgs, attrs);
        if (ret <= 0) {
+               talloc_free(sam_ctx);
+
                return NT_STATUS_NO_SUCH_DOMAIN;
        }
        if (ret > 1) {
                talloc_free(msgs);
+               talloc_free(sam_ctx);
+
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
 
@@ -4188,8 +4202,8 @@ static NTSTATUS dcesrv_samr_GetDomPwInfo(struct dcesrv_call_state *dce_call, TAL
                "pwdProperties", 1);
 
        talloc_free(msgs);
-
        talloc_free(sam_ctx);
+
        return NT_STATUS_OK;
 }
 
@@ -4342,7 +4356,11 @@ static NTSTATUS dcesrv_samr_SetDsrmPassword(struct dcesrv_call_state *dce_call,
 static NTSTATUS dcesrv_samr_ValidatePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                                      struct samr_ValidatePassword *r)
 {
-       DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+       /* just say it's OK for now - we need to hook this into our
+          password strength code later */
+       DEBUG(0,(__location__ ": Faking samr_ValidatePassword reply\n"));
+       (*r->out.rep) = talloc_zero(mem_ctx, union samr_ValidatePasswordRep);
+       return NT_STATUS_OK;
 }
 
 

diff --git a/source4/rpc_server/samr/samr_password.c b/source4/rpc_server/samr/samr_password.c
index 450af82895623b34d1d0f3f01836b89808eaf682..1e6eb47e86138b2c3f4955769643cc5793b5f3da 100644 (file)
--- a/source4/rpc_server/samr/samr_password.c
+++ b/source4/rpc_server/samr/samr_password.c
@@ -177,8 +177,9 @@ NTSTATUS dcesrv_samr_ChangePasswordUser(struct dcesrv_call_state *dce_call,
 /* 
   samr_OemChangePasswordUser2 
 */
-NTSTATUS dcesrv_samr_OemChangePasswordUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
-                                    struct samr_OemChangePasswordUser2 *r)
+NTSTATUS dcesrv_samr_OemChangePasswordUser2(struct dcesrv_call_state *dce_call,
+                                           TALLOC_CTX *mem_ctx,
+                                           struct samr_OemChangePasswordUser2 *r)
 {
        NTSTATUS status;
        DATA_BLOB new_password, new_unicode_password;
@@ -335,8 +336,8 @@ NTSTATUS dcesrv_samr_OemChangePasswordUser2(struct dcesrv_call_state *dce_call,
   samr_ChangePasswordUser3 
 */
 NTSTATUS dcesrv_samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call, 
-                                 TALLOC_CTX *mem_ctx,
-                                 struct samr_ChangePasswordUser3 *r)
+                                        TALLOC_CTX *mem_ctx,
+                                        struct samr_ChangePasswordUser3 *r)
 {      
        NTSTATUS status;
        DATA_BLOB new_password;
@@ -348,8 +349,8 @@ NTSTATUS dcesrv_samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call,
        struct samr_Password *nt_pwd, *lm_pwd;
        DATA_BLOB nt_pwd_blob;
        struct samr_DomInfo1 *dominfo = NULL;
-       struct samr_ChangeReject *reject = NULL;
-       enum samr_RejectReason reason = SAMR_REJECT_OTHER;
+       struct userPwdChangeFailureInformation *reject = NULL;
+       enum samPwdChangeReason reason = SAM_PWD_CHANGE_NO_ERROR;
        uint8_t new_nt_hash[16], new_lm_hash[16];
        struct samr_Password nt_verifier, lm_verifier;
 
@@ -465,6 +466,7 @@ NTSTATUS dcesrv_samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call,
                                    true, /* this is a user password change */
                                    &reason, 
                                    &dominfo);
+
        if (!NT_STATUS_IS_OK(status)) {
                goto failed;
        }
@@ -494,18 +496,16 @@ NTSTATUS dcesrv_samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call,
 
 failed:
        ldb_transaction_cancel(sam_ctx);
-       talloc_free(sam_ctx);
 
-       reject = talloc(mem_ctx, struct samr_ChangeReject);
-       *r->out.dominfo = dominfo;
-       *r->out.reject = reject;
+       reject = talloc(mem_ctx, struct userPwdChangeFailureInformation);
+       if (reject != NULL) {
+               ZERO_STRUCTP(reject);
+               reject->extendedFailureReason = reason;
 
-       if (reject == NULL) {
-               return status;
+               *r->out.reject = reject;
        }
-       ZERO_STRUCTP(reject);
 
-       reject->reason = reason;
+       *r->out.dominfo = dominfo;
 
        return status;
 }
@@ -516,12 +516,13 @@ failed:
 
   easy - just a subset of samr_ChangePasswordUser3
 */
-NTSTATUS dcesrv_samr_ChangePasswordUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
-                                 struct samr_ChangePasswordUser2 *r)
+NTSTATUS dcesrv_samr_ChangePasswordUser2(struct dcesrv_call_state *dce_call,
+                                        TALLOC_CTX *mem_ctx,
+                                        struct samr_ChangePasswordUser2 *r)
 {
        struct samr_ChangePasswordUser3 r2;
        struct samr_DomInfo1 *dominfo = NULL;
-       struct samr_ChangeReject *reject = NULL;
+       struct userPwdChangeFailureInformation *reject = NULL;
 
        r2.in.server = r->in.server;
        r2.in.account = r->in.account;
@@ -584,7 +585,8 @@ NTSTATUS samr_set_password(struct dcesrv_call_state *dce_call,
 */
 NTSTATUS samr_set_password_ex(struct dcesrv_call_state *dce_call,
                              struct ldb_context *sam_ctx,
-                             struct ldb_dn *account_dn, struct ldb_dn *domain_dn,
+                             struct ldb_dn *account_dn,
+                             struct ldb_dn *domain_dn,
                              TALLOC_CTX *mem_ctx,
                              struct ldb_message *msg, 
                              struct samr_CryptPasswordEx *pwbuf)
@@ -627,4 +629,3 @@ NTSTATUS samr_set_password_ex(struct dcesrv_call_state *dce_call,
                                  NULL, NULL);
 }
 
-

diff --git a/source4/rpc_server/spoolss/dcesrv_spoolss.c b/source4/rpc_server/spoolss/dcesrv_spoolss.c
index d380b10d8e06abd9215d7f61b6397ed1b0b38d07..0e071dc74c965747861791d404661a476c623b1b 100644 (file)
--- a/source4/rpc_server/spoolss/dcesrv_spoolss.c
+++ b/source4/rpc_server/spoolss/dcesrv_spoolss.c
@@ -150,6 +150,7 @@ static WERROR dcesrv_spoolss_check_server_name(struct dcesrv_call_state *dce_cal
        bool ret;
        struct socket_address *myaddr;
        const char **aliases;
+       const char *dnsdomain;
        int i;
 
        /* NULL is ok */
@@ -186,12 +187,13 @@ static WERROR dcesrv_spoolss_check_server_name(struct dcesrv_call_state *dce_cal
        /* DNS NAME is ok
         * TODO: we need to check if aliases are also ok
         */
-       if (lp_realm(dce_call->conn->dce_ctx->lp_ctx)) {
+       dnsdomain = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
+       if (dnsdomain != NULL) {
                char *str;
 
                str = talloc_asprintf(mem_ctx, "%s.%s",
                                                lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx),
-                                               lp_realm(dce_call->conn->dce_ctx->lp_ctx));
+                                               dnsdomain);
                W_ERROR_HAVE_NO_MEMORY(str);
 
                ret = strequal(str, server_name);

diff --git a/source4/rpc_server/srvsvc/srvsvc_ntvfs.c b/source4/rpc_server/srvsvc/srvsvc_ntvfs.c
index f1cb35bdd8978339c3b5da7326d11263f30f90ce..15bd749ad1b2eee79eedca91775638363bbfa50a 100644 (file)
--- a/source4/rpc_server/srvsvc/srvsvc_ntvfs.c
+++ b/source4/rpc_server/srvsvc/srvsvc_ntvfs.c
@@ -128,7 +128,9 @@ NTSTATUS srvsvc_create_ntvfs_context(struct dcesrv_call_state *dce_call,
        NT_STATUS_HAVE_NO_MEMORY(ntvfs_req);
 
        /* Invoke NTVFS connection hook */
-       status = ntvfs_connect(ntvfs_req, scfg->name);
+       /* FIXME: Here is the right parameter missing!
+         * status = ntvfs_connect(ntvfs_req, <TODO>); */
+       status = NT_STATUS_UNSUCCESSFUL; /* return this for now */
        if (!NT_STATUS_IS_OK(status)) {
                DEBUG(0,("srvsvc_create_ntvfs_context: NTVFS ntvfs_connect() failed!\n"));
                return status;

diff --git a/source4/script/minimal_includes.pl b/source4/script/minimal_includes.pl
index 2bcbd1152a2c07166e98af901756198028614128..d64409ed13de478b7957e6fcbc69f38bfe058c6e 100755 (executable)
--- a/source4/script/minimal_includes.pl
+++ b/source4/script/minimal_includes.pl
@@ -43,7 +43,7 @@ sub test_compile($)
 {
        my $fname = shift;
        my $obj;
-       if ($fname =~ s/(.*)\.c$/$1.o/) {
+       if ($fname =~ s/(.*)\..*$/$1.o/) {
                $obj = "$1.o";
        } else {
                return "NOT A C FILE";

diff --git a/source4/scripting/bin/reorgldb.py b/source4/scripting/bin/reorgldb.py
deleted file mode 100755 (executable)
index 571363f..0000000
--- a/source4/scripting/bin/reorgldb.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) Matthieu Patou <mat@matws.net> 2009
-# This script realize an offline reorganisation of an LDB
-# file it helps to reduce (sometime drastically) the
-# size of LDB files.
-import sys
-import optparse
-import os
-sys.path.insert(0, "bin/python")
-
-import samba
-from samba.credentials import DONT_USE_KERBEROS
-from samba.auth import system_session
-from samba import Ldb, substitute_var, valid_netbios_name, check_all_substituted
-from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
-import ldb
-import samba.getopt as options
-from samba.samdb import SamDB
-from samba import param
-from samba.provision import ProvisionPaths, ProvisionNames,provision_paths_from_lp, Schema
-
-parser = optparse.OptionParser("provision [options]")
-sambaopts = options.SambaOptions(parser)
-parser.add_option_group(sambaopts)
-parser.add_option_group(options.VersionOptions(parser))
-credopts = options.CredentialsOptions(parser)
-parser.add_option_group(credopts)
-parser.add_option("--database", type="string", metavar="FILE",
-        help="LDB to reorganize")
-opts = parser.parse_args()[0]
-lp = sambaopts.get_loadparm()
-smbconf = lp.configfile
-
-if not opts.database:
-       print "Parameter database is mandatory"
-       sys.exit(1)
-creds = credopts.get_credentials(lp)
-creds.set_kerberos_state(DONT_USE_KERBEROS)
-session = system_session()
-empty = ldb.Message()
-newname="%s.new"%(opts.database)
-if os.path.exists(newname):
-       os.remove(newname)
-old_ldb = Ldb(opts.database, session_info=session, credentials=creds,lp=lp)
-new_ldb = Ldb(newname,session_info=session, credentials=creds,lp=lp)
-
-new_ldb.transaction_start()
-res = old_ldb.search(expression="(dn=*)",base="", scope=SCOPE_SUBTREE)
-for i in range(0,len(res)):
-       if str(res[i].dn) == "@BASEINFO":
-               continue
-       if str(res[i].dn).startswith("@INDEX:"):
-               continue
-       delta = new_ldb.msg_diff(empty,res[i])
-       delta.dn = res[i].dn
-       delta.remove("distinguishedName")
-       new_ldb.add(delta)
-
-new_ldb.transaction_commit()

diff --git a/source4/scripting/bin/setup_dns.sh b/source4/scripting/bin/setup_dns.sh
index f296de2b8e7af1fcd4d03e135b2e5c4aba37cd49..f20ad145c1dec8bcdceb6a84aa72f795edc36d56 100755 (executable)
--- a/source4/scripting/bin/setup_dns.sh
+++ b/source4/scripting/bin/setup_dns.sh
@@ -33,5 +33,6 @@ scripting/bin/nsupdate-gss --realm=$DOMAIN --noverify --ntype="CNAME" $OBJECTGUI
     exit 1
 }
 echo "Checking"
+rndc flush
 host $HOSTNAME.$DOMAIN
 host $OBJECTGUID._msdcs.$DOMAIN

diff --git a/source4/scripting/bin/w32err_code.py b/source4/scripting/bin/w32err_code.py
new file mode 100755 (executable)
index 0000000..cad6f6e
--- /dev/null
+++ b/source4/scripting/bin/w32err_code.py
@@ -0,0 +1,361 @@
+#!/usr/bin/python
+
+# Unix SMB/CIFS implementation.
+# Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+#
+# 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/>.
+#
+
+"""Import generete werror.h/doserr.c files from WSPP HTML"""
+
+import re
+import os
+import sys
+import urllib
+import pprint
+from xml.dom import minidom
+from optparse import OptionParser, OptionGroup
+
+_wspp_werror_url = 'http://msdn.microsoft.com/en-us/library/cc231199%28PROT.10%29.aspx'
+
+class WerrorHtmlParser(object):
+    """
+    Parses HTML from WSPP documentation generating dictionary of
+    dictionaries with following keys:
+      - "err_hex" - hex number (as string)
+      - "err_name" - error name
+      - "err_desc" - error long description
+    For the key of returned dictionary err_hex is used,
+    i.e. "hex-error-code-str" => {error dictionary object}
+    """
+
+    ERROR_PREFIX = ['ERROR_', 'NERR_', 'FRS_', 'RPC_', 'EPT_', 'OR_', 'WAIT_TIMEOUT']
+    ERROR_REPLACE = ['ERROR_']
+
+    def __init__(self, opt):
+        self.opt = opt
+        self._errors_skipped = []
+        pass
+
+    def _is_error_code_name(self, err_name):
+        for pref in self.ERROR_PREFIX:
+            if err_name.startswith(pref):
+                return True
+        return False
+
+    def _make_werr_name(self, err_name):
+        err_name = err_name.upper()
+        for pref in self.ERROR_REPLACE:
+            if err_name.startswith(pref):
+                return err_name.replace(pref, 'WERR_', 1)
+        return 'WERR_' + err_name
+
+    def parse_url(self, url):
+        errors = {}
+        html = self._load_url(url)
+
+        # let minidom to parse the tree, should be:
+        # table -> tr -> td
+        #     p -> [hex code, br, error code]
+        #     p -> [description]
+        table_node = minidom.parseString(html)
+        for row_node in table_node.getElementsByTagName("tr"):
+            # verify we got right number of td elements
+            td_nodes = row_node.getElementsByTagName('td')
+            if len(td_nodes) != 2:
+                continue
+            # now get the real data
+            p_nodes = row_node.getElementsByTagName('p')
+            if len(p_nodes) != 2:   continue
+            if len(p_nodes[0].childNodes) != 3: continue
+            if len(p_nodes[1].childNodes) != 1: continue
+            err_hex = str(p_nodes[0].childNodes[0].nodeValue)
+            err_name = str(p_nodes[0].childNodes[2].nodeValue)
+            err_desc = p_nodes[1].childNodes[0].nodeValue.encode('utf-8')
+            err_desc = err_desc.replace('"', '\\"').replace("\'", "\\'")
+            # do some checking
+            if not err_hex.startswith('0x'):    continue
+            if not self._is_error_code_name(err_name):
+                self._errors_skipped.append("%s - %s - %d" % (err_name, err_hex, int(err_hex, 16)))
+                continue
+            # create entry
+            err_name = self._make_werr_name(err_name)
+            err_def = {'err_hex': err_hex,
+                       'err_name': err_name,
+                       'err_desc': err_desc,
+                       'code': int(err_hex, 16)}
+            errors[err_def['code']] = err_def
+
+        # print skipped errors
+        if self.opt.print_skipped and len(self._errors_skipped):
+            print "\nErrors skipped during HTML parsing:"
+            pprint.pprint(self._errors_skipped)
+            print "\n"
+
+        return errors
+
+    def _load_url(self, url):
+        html_str = ""
+        try:
+            fp = urllib.urlopen(url)
+            for line in fp:
+                html_str += line.strip()
+            fp.close()
+        except IOError, e:
+            print "error loading url: " + e.strerror
+            pass
+
+        # currently ERROR codes are rendered as table
+        # locate table chunk with ERROR_SUCCESS
+        html = [x for x in html_str.split('<table ') if "ERROR_SUCCESS" in x]
+        html = '<table ' + html[0]
+        pos = html.find('</table>')
+        if pos == -1:
+            return '';
+        html = html[:pos] + '</table>'
+
+        # html clean up
+        html = re.sub(r'<a[^>]*>(.*?)</a>', r'\1', html)
+
+        return html
+
+
+class WerrorGenerator(object):
+    """
+    provides methods to generate parts of werror.h and doserr.c files
+    """
+
+    FNAME_WERRORS   = 'w32errors.lst'
+    FNAME_WERROR_DEFS  = 'werror_defs.h'
+    FNAME_DOSERR_DEFS = 'doserr_defs.c'
+    FNAME_DOSERR_DESC = 'doserr_desc.c'
+
+    def __init__(self, opt):
+        self.opt = opt
+        self._out_dir = opt.out_dir
+        pass
+
+    def _open_out_file(self, fname):
+        fname = os.path.join(self._out_dir, fname)
+        return open(fname, "w")
+
+    def _gen_werrors_list(self, errors):
+        """uses 'errors' dictionary to display list of Win32 Errors"""
+
+        fp = self._open_out_file(self.FNAME_WERRORS)
+        for err_code in sorted(errors.keys()):
+            err_name = errors[err_code]['err_name']
+            fp.write(err_name)
+            fp.write("\n")
+        fp.close()
+
+    def _gen_werror_defs(self, errors):
+        """uses 'errors' dictionary to generate werror.h file"""
+
+        fp = self._open_out_file(self.FNAME_WERROR_DEFS)
+        for err_code in sorted(errors.keys()):
+            err_name = errors[err_code]['err_name']
+            err_hex = errors[err_code]['err_hex']
+            fp.write('#define %s\tW_ERROR(%s)' % (err_name, err_hex))
+            fp.write("\n")
+        fp.close()
+
+    def _gen_doserr_defs(self, errors):
+        """uses 'errors' dictionary to generate defines in doserr.c file"""
+
+        fp = self._open_out_file(self.FNAME_DOSERR_DEFS)
+        for err_code in sorted(errors.keys()):
+            err_name = errors[err_code]['err_name']
+            fp.write('\t{ "%s", %s },' % (err_name, err_name))
+            fp.write("\n")
+        fp.close()
+
+    def _gen_doserr_descriptions(self, errors):
+        """uses 'errors' dictionary to generate descriptions in doserr.c file"""
+
+        fp = self._open_out_file(self.FNAME_DOSERR_DESC)
+        for err_code in sorted(errors.keys()):
+            err_name = errors[err_code]['err_name']
+            fp.write('\t{ %s, "%s" },' % (err_name, errors[err_code]['err_desc']))
+            fp.write("\n")
+        fp.close()
+
+    def _lookup_error_by_name(self, err_name, defined_errors):
+        for err in defined_errors.itervalues():
+            if err['err_name'] == err_name:
+                return err
+        return None
+
+    def _filter_errors(self, errors, defined_errors):
+        """
+        returns tuple (new_erros, diff_code_errors, diff_name_errors)
+        new_errors - dictionary of errors not in defined_errors
+        diff_code_errors - list of errors found in defined_errors
+                           but with different value
+        diff_name_errors - list of errors found with same code in
+                            defined_errors, but with different name
+        Most critical is diff_code_errors list to be empty!
+        """
+        new_errors = {}
+        diff_code_errors = []
+        diff_name_errors = []
+        for err_def in errors.itervalues():
+            add_error = True
+            # try get defined error by code
+            if defined_errors.has_key(err_def['code']):
+                old_err = defined_errors[err_def['code']]
+                if err_def['err_name'] != old_err['err_name']:
+                    warning = {'msg': 'New and Old errors has different error names',
+                               'err_new': err_def,
+                               'err_old': old_err}
+                    diff_name_errors.append(warning)
+
+            # sanity check for errors with same name but different values
+            old_err = self._lookup_error_by_name(err_def['err_name'], defined_errors)
+            if old_err:
+                if err_def['code'] != old_err['code']:
+                    warning = {'msg': 'New and Old error defs has different error value',
+                               'err_new': err_def,
+                               'err_old': old_err}
+                    diff_code_errors.append(warning)
+                # exclude error already defined with same name
+                add_error = False
+            # do add the error in new_errors if everything is fine
+            if add_error:
+                new_errors[err_def['code']] = err_def
+            pass
+        return (new_errors, diff_code_errors, diff_name_errors)
+
+    def generate(self, errors):
+        # load already defined error codes
+        werr_parser = WerrorParser(self.opt)
+        (defined_errors,
+         no_value_errors) = werr_parser.load_err_codes(self.opt.werror_file)
+        if not defined_errors:
+            print "\nUnable to load existing errors file: %s" % self.opt.werror_file
+            sys.exit(1)
+        if self.opt.verbose and len(no_value_errors):
+            print "\nWarning: there are errors defines using macro value:"
+            pprint.pprint(no_value_errors)
+            print ""
+        # filter generated error codes
+        (new_errors,
+         diff_code_errors,
+         diff_name_errors) = self._filter_errors(errors, defined_errors)
+        if diff_code_errors:
+            print("\nFound %d errors with same names but different error values! Aborting."
+                  % len(diff_code_errors))
+            pprint.pprint(diff_code_errors)
+            sys.exit(2)
+
+        if diff_name_errors:
+            print("\nFound %d errors with same values but different names (should be normal)"
+                  % len(diff_name_errors))
+            pprint.pprint(diff_name_errors)
+
+        # finally generate output files
+        self._gen_werror_defs(new_errors)
+        self._gen_doserr_defs(new_errors)
+        self._gen_werrors_list(errors)
+        self._gen_doserr_descriptions(errors)
+        pass
+
+class WerrorParser(object):
+    """
+    Parses errors defined in werror.h file
+    """
+
+    def __init__(self, opt):
+        self.opt = opt
+        pass
+
+    def _parse_werror_line(self, line):
+        m = re.match('#define[ \t]*(.*?)[ \t]*W_ERROR\((.*?)\)', line)
+        if not m or (len(m.groups()) != 2):
+            return None
+        if len(m.group(1)) == 0:
+            return None
+        if str(m.group(2)).startswith('0x'):
+            err_code = int(m.group(2), 16)
+        elif m.group(2).isdigit():
+            err_code = int(m.group(2))
+        else:
+            self.err_no_values.append(line)
+            return None
+        return {'err_name': str(m.group(1)),
+                'err_hex': "0x%08X" % err_code,
+                'code': err_code}
+        pass
+
+    def load_err_codes(self, fname):
+        """
+        Returns tuple of:
+            dictionary of "hex_err_code" => {code, name}
+                "hex_err_code" is string
+                "code" is int value for the error
+            list of errors that was ignored for some reason
+        """
+        # reset internal variables
+        self.err_no_values = []
+        err_codes = {}
+        fp = open(fname)
+        for line in fp.readlines():
+            err_def = self._parse_werror_line(line)
+            if err_def:
+                err_codes[err_def['code']] = err_def
+        fp.close();
+        return (err_codes, self.err_no_values)
+
+
+
+def _generate_files(opt):
+    parser = WerrorHtmlParser(opt)
+    errors = parser.parse_url(opt.url)
+
+    out = WerrorGenerator(opt)
+    out.generate(errors)
+    pass
+
+
+if __name__ == '__main__':
+    _cur_dir = os.path.abspath(os.path.dirname(__file__))
+    opt_parser = OptionParser(usage="usage: %prog [options]", version="%prog 0.3")
+    opt_group = OptionGroup(opt_parser, "Main options")
+    opt_group.add_option("--url", dest="url",
+                         default=_wspp_werror_url,
+                         help="url for w32 error codes html - may be local file")
+    opt_group.add_option("--out", dest="out_dir",
+                         default=_cur_dir,
+                         help="output dir for generated files")
+    opt_group.add_option("--werror", dest="werror_file",
+                         default=os.path.join(_cur_dir, 'werror.h'),
+                         help="path to werror.h file")
+    opt_group.add_option("--print_skipped",
+                        action="store_true", dest="print_skipped", default=False,
+                        help="print errors skipped during HTML parsing")
+    opt_group.add_option("-q", "--quiet",
+                        action="store_false", dest="verbose", default=True,
+                        help="don't print warnings to stdout")
+
+    opt_parser.add_option_group(opt_group)
+
+    (options, args) = opt_parser.parse_args()
+
+    # add some options to be used internally
+    options.err_defs_file = os.path.join(options.out_dir, WerrorGenerator.FNAME_WERROR_DEFS)
+    options.dos_defs_file = os.path.join(options.out_dir, WerrorGenerator.FNAME_DOSERR_DEFS)
+    options.dos_desc_file = os.path.join(options.out_dir, WerrorGenerator.FNAME_DOSERR_DESC)
+
+    # check options
+    _generate_files(options)

diff --git a/source4/scripting/devel/drs/fsmo.ldif.template b/source4/scripting/devel/drs/fsmo.ldif.template
new file mode 100644 (file)
index 0000000..d5b373a
--- /dev/null
+++ b/source4/scripting/devel/drs/fsmo.ldif.template
@@ -0,0 +1,75 @@
+dn: CN=RID Manager$,CN=System,BASEDN
+changetype: modify
+replace: fSMORoleOwner
+fSMORoleOwner: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,C
+ N=Sites,CN=Configuration,BASEDN
+-
+
+dn: BASEDN
+changetype: modify
+replace: fSMORoleOwner
+fSMORoleOwner: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,C
+ N=Sites,CN=Configuration,BASEDN
+-
+
+dn: CN=Infrastructure,BASEDN
+changetype: modify
+replace: fSMORoleOwner
+fSMORoleOwner: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,C
+ N=Sites,CN=Configuration,BASEDN
+-
+
+dn: CN=Partitions,CN=Configuration,BASEDN
+changetype: modify
+replace: fSMORoleOwner
+fSMORoleOwner: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,BASEDN
+-
+
+dn: CN=Schema,CN=Configuration,BASEDN
+changetype: modify
+replace: fSMORoleOwner
+fSMORoleOwner: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,BASEDN
+-
+
+dn: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,BASEDN
+changetype: modify
+replace: options
+options: 1
+-
+
+dn: CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,BASEDN
+changetype: modify
+replace: dNSHostName
+dNSHostName: MACHINE.DNSDOMAIN
+-
+
+dn: CN=NTDS Site Settings,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,BASEDN
+changetype: modify
+replace: interSiteTopologyGenerator
+interSiteTopologyGenerator: CN=NTDS Settings,CN=MACHINE,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,BASEDN
+-
+
+dn: CN=MACHINE,OU=Domain Controllers,BASEDN
+changetype: modify
+replace: servicePrincipalName
+servicePrincipalName: GC/MACHINE.DNSDOMAIN/DNSDOMAIN
+servicePrincipalName: HOST/MACHINE/NETBIOSDOMAIN
+servicePrincipalName: ldap/MACHINE/NETBIOSDOMAIN
+servicePrincipalName: ldap/MACHINE.DNSDOMAIN/ForestDnsZones.DNSDOMAIN
+servicePrincipalName: ldap/MACHINE.DNSDOMAIN/DomainDnsZones.DNSDOMAIN
+servicePrincipalName: DNS/MACHINE.DNSDOMAIN
+servicePrincipalName: RestrictedKrbHost/MACHINE.DNSDOMAIN
+servicePrincipalName: RestrictedKrbHost/MACHINE
+servicePrincipalName: HOST/MACHINE.DNSDOMAIN/NETBIOSDOMAIN
+servicePrincipalName: HOST/MACHINE
+servicePrincipalName: HOST/MACHINE.DNSDOMAIN
+servicePrincipalName: HOST/MACHINE.DNSDOMAIN/DNSDOMAIN
+servicePrincipalName: ldap/MACHINE.DNSDOMAIN/NETBIOSDOMAIN
+servicePrincipalName: ldap/MACHINE
+servicePrincipalName: ldap/MACHINE.DNSDOMAIN
+servicePrincipalName: ldap/MACHINE.DNSDOMAIN/DNSDOMAIN
+servicePrincipalName: E3514235-4B06-11D1-AB04-00C04FC2DCD2/NTDSGUID/DNSDOMAIN
+servicePrincipalName: ldap/NTDSGUID._msdcs.DNSDOMAIN
+servicePrincipalName: Dfsr-12F9A27C-BF97-4787-9364-D31B6C55EB04/MACHINE.DNSDOMAIN
+servicePrincipalName: NtFrs-88f5d2bd-b646-11d2-a6d3-00c04fc9b232/MACHINE.DNSDOMAIN
+-

diff --git a/source4/scripting/devel/drs/named.conf.ad.template b/source4/scripting/devel/drs/named.conf.ad.template
new file mode 100644 (file)
index 0000000..071c98c
--- /dev/null
+++ b/source4/scripting/devel/drs/named.conf.ad.template
@@ -0,0 +1,6 @@
+zone "DNSDOMAIN" IN {
+     type forward;
+     forwarders {
+                SERVERIP;
+     };
+};

diff --git a/source4/scripting/devel/drs/revampire_ad.sh b/source4/scripting/devel/drs/revampire_ad.sh
new file mode 100755 (executable)
index 0000000..522601c
--- /dev/null
+++ b/source4/scripting/devel/drs/revampire_ad.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -x
+
+. `dirname $0`/vars
+
+`dirname $0`/vampire_ad.sh || exit 1
+
+ntds_guid=$(sudo bin/ldbsearch -H $PREFIX/private/sam.ldb -b "CN=NTDS Settings,CN=$machine,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,$dn" objectGUID|grep ^objectGUID| awk '{print $2}')
+
+cp $PREFIX/private/$DNSDOMAIN.zone{.template,}
+sed -i "s/NTDSGUID/$ntds_guid/g" $PREFIX/private/$DNSDOMAIN.zone
+cp $PREFIX/private/named.conf{.local,}
+sudo rndc reconfig
+fsmotmp=`mktemp fsmo.ldif.XXXXXXXXX`
+cp `dirname $0`/fsmo.ldif.template $fsmotmp
+sed -i "s/NTDSGUID/$ntds_guid/g" $fsmotmp
+sed -i "s/MACHINE/$machine/g" $fsmotmp
+sed -i "s/DNSDOMAIN/$DNSDOMAIN/g" $fsmotmp
+sed -i "s/BASEDN/$dn/g" $fsmotmp
+sed -i "s/NETBIOSDOMAIN/$workgroup/g" $fsmotmp
+sudo bin/ldbmodify -H $PREFIX/private/sam.ldb $fsmotmp
+rm $fsmotmp

diff --git a/source4/scripting/devel/drs/unvampire_ad.sh b/source4/scripting/devel/drs/unvampire_ad.sh
new file mode 100755 (executable)
index 0000000..e4b9dcc
--- /dev/null
+++ b/source4/scripting/devel/drs/unvampire_ad.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -x
+
+. `dirname $0`/vars
+
+
+bin/ldbdel -H ldap://$server.$DNSDOMAIN -U$workgroup/administrator%$pass "CN=$machine,CN=Computers,$dn"
+bin/ldbdel -H ldap://$server.$DNSDOMAIN -U$workgroup/administrator%$pass "CN=$machine,OU=Domain Controllers,$dn"
+bin/ldbdel -H ldap://$server.$DNSDOMAIN -U$workgroup/administrator%$pass "CN=NTDS Settings,CN=$machine,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,$dn"
+bin/ldbdel -H ldap://$server.$DNSDOMAIN -U$workgroup/administrator%$pass "CN=$machine,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,$dn"
+rm -f $PREFIX/private/*.ldb

diff --git a/source4/scripting/devel/drs/vampire_ad.sh b/source4/scripting/devel/drs/vampire_ad.sh
new file mode 100755 (executable)
index 0000000..baba02d
--- /dev/null
+++ b/source4/scripting/devel/drs/vampire_ad.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -x
+
+. `dirname $0`/vars
+
+namedtmp=`mktemp named.conf.ad.XXXXXXXXX`
+cp `dirname $0`/named.conf.ad.template $namedtmp
+sed -i "s/DNSDOMAIN/$DNSDOMAIN/g" $namedtmp
+sed -i "s/SERVERIP/$server_ip/g" $namedtmp
+chmod a+r $namedtmp
+mv -f $namedtmp $PREFIX/private/named.conf
+sudo rndc reconfig
+`dirname $0`/unvampire_ad.sh
+sudo bin/net vampire $DNSDOMAIN -Uadministrator%$pass -s $PREFIX/etc/smb.conf -d2 || exit 1
+PRIVATEDIR=$PREFIX/private sudo -E scripting/bin/setup_dns.sh $machine $DNSDOMAIN $machine_ip || exit 1
+sudo rndc flush

diff --git a/source4/scripting/devel/drs/vars b/source4/scripting/devel/drs/vars
new file mode 100644 (file)
index 0000000..e1fe53c
--- /dev/null
+++ b/source4/scripting/devel/drs/vars
@@ -0,0 +1,11 @@
+DNSDOMAIN=ad.samba.example.com
+PREFIX="/data/samba/samba4/prefix.ad"
+export PYTHONPATH=$PYTHONPATH:$PREFIX/lib/python2.6/site-packages
+pass="penguin"
+machine="ruth"
+machine_ip="192.168.122.1"
+workgroup=adruth
+dn="DC=ad,DC=samba,DC=example,DC=com"
+server=win2008-1
+server_ip=192.168.122.53
+

diff --git a/source4/scripting/python/samba/__init__.py b/source4/scripting/python/samba/__init__.py
index 82df4960cf9631520d599f117de856181ee504f9..57cefdd1373f8368d81ed9a23507782fd350691b 100644 (file)
--- a/source4/scripting/python/samba/__init__.py
+++ b/source4/scripting/python/samba/__init__.py
@@ -234,14 +234,14 @@ class Ldb(ldb.Ldb):
         """
         self.add_ldif(open(ldif_path, 'r').read())
 
-    def add_ldif(self, ldif):
+    def add_ldif(self, ldif,controls=None):
         """Add data based on a LDIF string.
 
         :param ldif: LDIF text.
         """
         for changetype, msg in self.parse_ldif(ldif):
             assert changetype == ldb.CHANGETYPE_NONE
-            self.add(msg)
+            self.add(msg,controls)
 
     def modify_ldif(self, ldif):
         """Modify database based on a LDIF string.

diff --git a/source4/scripting/python/samba/provision.py b/source4/scripting/python/samba/provision.py
index 64491c2b18dcff3a81f557dcc3127dfa8ad77681..d7fadf3b7eff82243088ff1eb576831920912e76 100644 (file)
--- a/source4/scripting/python/samba/provision.py
+++ b/source4/scripting/python/samba/provision.py
@@ -44,7 +44,7 @@ from credentials import Credentials, DONT_USE_KERBEROS
 from auth import system_session, admin_session
 from samba import version, Ldb, substitute_var, valid_netbios_name
 from samba import check_all_substituted
-from samba import DS_DOMAIN_FUNCTION_2000, DS_DOMAIN_FUNCTION_2008, DS_DC_FUNCTION_2008, DS_DC_FUNCTION_2008_R2
+from samba import DS_DOMAIN_FUNCTION_2003, DS_DOMAIN_FUNCTION_2008, DS_DC_FUNCTION_2008
 from samba.samdb import SamDB
 from samba.idmap import IDmapDB
 from samba.dcerpc import security
@@ -144,6 +144,11 @@ class ProvisionPaths(object):
         self.fedoradsinf = None
         self.fedoradspartitions = None
         self.fedoradssasl = None
+        self.fedoradspam = None
+        self.fedoradsrefint = None
+        self.fedoradslinkedattributes = None
+        self.fedoradsindex = None
+        self.fedoradssamba = None
         self.olmmron = None
         self.olmmrserveridsconf = None
         self.olmmrsyncreplconf = None
@@ -210,6 +215,8 @@ class Schema(object):
         prefixmap = open(setup_path("prefixMap.txt"), 'r').read()
         prefixmap = b64encode(prefixmap)
 
+        
+
         # We don't actually add this ldif, just parse it
         prefixmap_ldif = "dn: cn=schema\nprefixMap:: %s\n\n" % prefixmap
         self.ldb.set_schema_from_ldif(prefixmap_ldif, self.schema_data)
@@ -288,17 +295,17 @@ def read_and_sub_file(file, subst_vars):
     return data
 
 
-def setup_add_ldif(ldb, ldif_path, subst_vars=None):
+def setup_add_ldif(ldb, ldif_path, subst_vars=None,controls=["relax:0"]):
     """Setup a ldb in the private dir.
     
     :param ldb: LDB file to import data into
     :param ldif_path: Path of the LDIF file to load
     :param subst_vars: Optional variables to subsitute in LDIF.
+    :param nocontrols: Optional list of controls, can be None for no controls
     """
     assert isinstance(ldif_path, str)
-
     data = read_and_sub_file(ldif_path, subst_vars)
-    ldb.add_ldif(data)
+    ldb.add_ldif(data,controls)
 
 
 def setup_modify_ldif(ldb, ldif_path, subst_vars=None):
@@ -332,7 +339,7 @@ def setup_ldb(ldb, ldif_path, subst_vars):
     ldb.transaction_commit()
 
 
-def setup_file(template, fname, subst_vars):
+def setup_file(template, fname, subst_vars=None):
     """Setup a file in the private dir.
 
     :param template: Path of the template file.
@@ -362,6 +369,7 @@ def provision_paths_from_lp(lp, dnsdomain):
     paths.samdb = os.path.join(paths.private_dir, lp.get("sam database") or "samdb.ldb")
     paths.idmapdb = os.path.join(paths.private_dir, lp.get("idmap database") or "idmap.ldb")
     paths.secrets = os.path.join(paths.private_dir, lp.get("secrets database") or "secrets.ldb")
+    paths.privilege = os.path.join(paths.private_dir, "privilege.ldb")
     paths.dns = os.path.join(paths.private_dir, dnsdomain + ".zone")
     paths.namedconf = os.path.join(paths.private_dir, "named.conf")
     paths.namedtxt = os.path.join(paths.private_dir, "named.txt")
@@ -386,8 +394,16 @@ def provision_paths_from_lp(lp, dnsdomain):
                                             "fedorads-partitions.ldif")
     paths.fedoradssasl = os.path.join(paths.ldapdir, 
                                       "fedorads-sasl.ldif")
+    paths.fedoradspam = os.path.join(paths.ldapdir,
+                                      "fedorads-pam.ldif")
+    paths.fedoradsrefint = os.path.join(paths.ldapdir,
+                                        "fedorads-refint.ldif")
+    paths.fedoradslinkedattributes = os.path.join(paths.ldapdir,
+                                                  "fedorads-linked-attributes.ldif")
+    paths.fedoradsindex = os.path.join(paths.ldapdir,
+                                       "fedorads-index.ldif")
     paths.fedoradssamba = os.path.join(paths.ldapdir, 
-                                        "fedorads-samba.ldif")
+                                       "fedorads-samba.ldif")
     paths.olmmrserveridsconf = os.path.join(paths.ldapdir, 
                                             "mmr_serverids.conf")
     paths.olmmrsyncreplconf = os.path.join(paths.ldapdir, 
@@ -427,7 +443,7 @@ def guess_names(lp=None, hostname=None, domain=None, dnsdomain=None,
     hostname = hostname.lower()
 
     if dnsdomain is None:
-        dnsdomain = lp.get("realm")
+        dnsdomain = lp.get("realm").lower()
 
     if serverrole is None:
         serverrole = lp.get("server role")
@@ -439,8 +455,6 @@ def guess_names(lp=None, hostname=None, domain=None, dnsdomain=None,
         raise Exception("realm '%s' in %s must match chosen realm '%s'" %
                         (lp.get("realm"), lp.configfile, realm))
     
-    dnsdomain = dnsdomain.lower()
-
     if serverrole == "domain controller":
         if domain is None:
             domain = lp.get("workgroup")
@@ -452,20 +466,21 @@ def guess_names(lp=None, hostname=None, domain=None, dnsdomain=None,
     else:
         domain = netbiosname
         if domaindn is None:
-            domaindn = "CN=" + netbiosname
+            domaindn = "DC=" + netbiosname
         
     assert domain is not None
     domain = domain.upper()
+
     if not valid_netbios_name(domain):
         raise InvalidNetbiosName(domain)
         
-    if netbiosname.upper() == realm.upper():
+    if netbiosname.upper() == realm:
         raise Exception("realm %s must not be equal to netbios domain name %s", realm, netbiosname)
         
-    if hostname.upper() == realm.upper():
+    if hostname.upper() == realm:
         raise Exception("realm %s must not be equal to hostname %s", realm, hostname)
         
-    if domain.upper() == realm.upper():
+    if domain.upper() == realm:
         raise Exception("realm %s must not be equal to domain name %s", realm, domain)
 
     if rootdn is None:
@@ -614,6 +629,7 @@ def setup_samdb_partitions(samdb_path, setup_path, message, lp, session_info,
     # - each partition has its own module list then
     modules_list = ["resolve_oids",
                     "rootdse",
+                    "lazy_commit",
                     "acl",
                     "paged_results",
                     "ranged_results",
@@ -628,7 +644,8 @@ def setup_samdb_partitions(samdb_path, setup_path, message, lp, session_info,
                     "samldb",
                     "password_hash",
                     "operational",
-                    "kludge_acl"]
+                    "kludge_acl", 
+                    "instancetype"]
     tdb_modules_list = [
                     "subtree_rename",
                     "subtree_delete",
@@ -648,7 +665,7 @@ def setup_samdb_partitions(samdb_path, setup_path, message, lp, session_info,
         if ldap_backend.ldap_backend_type == "fedora-ds":
             backend_modules = ["nsuniqueid", "paged_searches"]
             # We can handle linked attributes here, as we don't have directory-side subtree operations
-            tdb_modules_list = ["linked_attributes", "extended_dn_out_dereference"]
+            tdb_modules_list = ["extended_dn_out_dereference"]
         elif ldap_backend.ldap_backend_type == "openldap":
             backend_modules = ["entryuuid", "paged_searches"]
             # OpenLDAP handles subtree renames, so we don't want to do any of these things
@@ -676,9 +693,9 @@ def setup_samdb_partitions(samdb_path, setup_path, message, lp, session_info,
                 "CONFIGDN_LDB": configdn_ldb,
                 "DOMAINDN": names.domaindn,
                 "DOMAINDN_LDB": domaindn_ldb,
-                "SCHEMADN_MOD": "schema_fsmo,instancetype",
-                "CONFIGDN_MOD": "naming_fsmo,instancetype",
-                "DOMAINDN_MOD": "pdc_fsmo,instancetype",
+                "SCHEMADN_MOD": "schema_fsmo",
+                "CONFIGDN_MOD": "naming_fsmo",
+                "DOMAINDN_MOD": "pdc_fsmo",
                 "MODULES_LIST": ",".join(modules_list),
                 "TDB_MODULES_LIST": tdb_modules_list_as_string,
                 "MODULES_LIST2": ",".join(modules_list2),
@@ -814,6 +831,23 @@ def setup_secretsdb(path, setup_path, session_info, credentials, lp):
 
     return secrets_ldb
 
+def setup_privileges(path, setup_path, session_info, lp):
+    """Setup the privileges database.
+
+    :param path: Path to the privileges database.
+    :param setup_path: Get the path to a setup file.
+    :param session_info: Session info.
+    :param credentials: Credentials
+    :param lp: Loadparm context
+    :return: LDB handle for the created secrets database
+    """
+    if os.path.exists(path):
+        os.unlink(path)
+    privilege_ldb = Ldb(path, session_info=session_info, lp=lp)
+    privilege_ldb.erase()
+    privilege_ldb.load_ldif_file_add(setup_path("provision_privilege.ldif"))
+
+
 def setup_registry(path, setup_path, session_info, lp):
     """Setup the registry.
     
@@ -874,9 +908,14 @@ def setup_samdb_rootdse(samdb, setup_path, names):
 def setup_self_join(samdb, names,
                     machinepass, dnspass, 
                     domainsid, invocationid, setup_path,
-                    policyguid, policyguid_dc, domainControllerFunctionality):
+                    policyguid, policyguid_dc, domainControllerFunctionality,
+                    ntdsguid):
     """Join a host to its own domain."""
     assert isinstance(invocationid, str)
+    if ntdsguid is not None:
+        ntdsguid_line = "objectGUID: %s\n"%ntdsguid
+    else:
+        ntdsguid_line = ""
     setup_add_ldif(samdb, setup_path("provision_self_join.ldif"), { 
               "CONFIGDN": names.configdn, 
               "SCHEMADN": names.schemadn,
@@ -892,6 +931,7 @@ def setup_self_join(samdb, names,
               "DOMAIN": names.domain,
               "DNSDOMAIN": names.dnsdomain,
               "SAMBA_VERSION_STRING": version,
+              "NTDSGUID": ntdsguid_line,
               "DOMAIN_CONTROLLER_FUNCTIONALITY": str(domainControllerFunctionality)})
 
     setup_add_ldif(samdb, setup_path("provision_group_policy.ldif"), { 
@@ -925,23 +965,34 @@ def setup_samdb(path, setup_path, session_info, credentials, lp,
                 names, message, 
                 domainsid, domainguid, policyguid, policyguid_dc,
                 fill, adminpass, krbtgtpass, 
-                machinepass, invocationid, dnspass,
-                serverrole, schema=None, ldap_backend=None):
+                machinepass, invocationid, dnspass, ntdsguid,
+                serverrole, dom_for_fun_level=None,
+                schema=None, ldap_backend=None):
     """Setup a complete SAM Database.
     
     :note: This will wipe the main SAM database file!
     """
 
-    # Do NOT change these default values without discussion with the team and reslease manager.  
-    domainFunctionality = DS_DOMAIN_FUNCTION_2008
-    forestFunctionality = DS_DOMAIN_FUNCTION_2008
+    # ATTENTION: Do NOT change these default values without discussion with the
+    # team and/or release manager. They have a big impact on the whole program!
     domainControllerFunctionality = DS_DC_FUNCTION_2008
 
+    if dom_for_fun_level is None:
+        dom_for_fun_level = DS_DOMAIN_FUNCTION_2003
+    if dom_for_fun_level < DS_DOMAIN_FUNCTION_2003:
+        raise ProvisioningError("You want to run SAMBA 4 on a domain and forest function level lower than Windows 2003 (Native). This isn't supported!")
+
+    if dom_for_fun_level > domainControllerFunctionality:
+        raise ProvisioningError("You want to run SAMBA 4 on a domain and forest function level which itself is higher than its actual DC function level (2008). This won't work!")
+
+    domainFunctionality = dom_for_fun_level
+    forestFunctionality = dom_for_fun_level
+
     # Also wipes the database
     setup_samdb_partitions(path, setup_path, message=message, lp=lp,
                            credentials=credentials, session_info=session_info,
-                           names=names, 
-                           ldap_backend=ldap_backend, serverrole=serverrole)
+                           names=names, ldap_backend=ldap_backend,
+                           serverrole=serverrole)
 
     if (schema == None):
         schema = Schema(setup_path, domainsid, schemadn=names.schemadn, serverdn=names.serverdn,
@@ -989,28 +1040,22 @@ def setup_samdb(path, setup_path, session_info, credentials, lp,
             samdb.set_invocation_id(invocationid)
 
         message("Adding DomainDN: %s" % names.domaindn)
-        if serverrole == "domain controller":
-            domain_oc = "domainDNS"
-        else:
-            domain_oc = "samba4LocalDomain"
 
 #impersonate domain admin
         admin_session_info = admin_session(lp, str(domainsid))
         samdb.set_session_info(admin_session_info)
-
+        if domainguid is not None:
+            domainguid_line = "objectGUID: %s\n-" % domainguid
+        else:
+            domainguid_line = ""
         setup_add_ldif(samdb, setup_path("provision_basedn.ldif"), {
                 "DOMAINDN": names.domaindn,
-                "DOMAIN_OC": domain_oc
+                "DOMAINGUID": domainguid_line
                 })
 
-        message("Modifying DomainDN: " + names.domaindn + "")
-        if domainguid is not None:
-            domainguid_mod = "replace: objectGUID\nobjectGUID: %s\n-" % domainguid
-        else:
-            domainguid_mod = ""
 
         setup_modify_ldif(samdb, setup_path("provision_basedn_modify.ldif"), {
-            "CREATTIME": str(int(time.time()) * 1e7), # seconds -> ticks
+            "CREATTIME": str(int(time.time() * 1e7)), # seconds -> ticks
             "DOMAINSID": str(domainsid),
             "SCHEMADN": names.schemadn, 
             "NETBIOSNAME": names.netbiosname,
@@ -1019,7 +1064,6 @@ def setup_samdb(path, setup_path, session_info, credentials, lp,
             "SERVERDN": names.serverdn,
             "POLICYGUID": policyguid,
             "DOMAINDN": names.domaindn,
-            "DOMAINGUID_MOD": domainguid_mod,
             "DOMAIN_FUNCTIONALITY": str(domainFunctionality),
             "SAMBA_VERSION_STRING": version
             })
@@ -1038,10 +1082,10 @@ def setup_samdb(path, setup_path, session_info, credentials, lp,
 
         # The LDIF here was created when the Schema object was constructed
         message("Setting up sam.ldb schema")
-        samdb.add_ldif(schema.schema_dn_add)
+        samdb.add_ldif(schema.schema_dn_add, controls=["relax:0"])
         samdb.modify_ldif(schema.schema_dn_modify)
         samdb.write_prefixes_from_schema()
-        samdb.add_ldif(schema.schema_data)
+        samdb.add_ldif(schema.schema_data, controls=["relax:0"])
         setup_add_ldif(samdb, setup_path("aggregate_schema.ldif"), 
                        {"SCHEMADN": names.schemadn})
 
@@ -1078,7 +1122,7 @@ def setup_samdb(path, setup_path, session_info, credentials, lp,
                 "DOMAINDN": names.domaindn})
         message("Setting up sam.ldb data")
         setup_add_ldif(samdb, setup_path("provision.ldif"), {
-            "CREATTIME": str(int(time.time()) * 1e7), # seconds -> ticks
+            "CREATTIME": str(int(time.time() * 1e7)), # seconds -> ticks
             "DOMAINDN": names.domaindn,
             "NETBIOSNAME": names.netbiosname,
             "DEFAULTSITE": names.sitename,
@@ -1105,7 +1149,8 @@ def setup_samdb(path, setup_path, session_info, credentials, lp,
                                 domainsid=domainsid, policyguid=policyguid,
                                 policyguid_dc=policyguid_dc,
                                 setup_path=setup_path,
-                                domainControllerFunctionality=domainControllerFunctionality)
+                                domainControllerFunctionality=domainControllerFunctionality,
+                                ntdsguid=ntdsguid)
 
                 ntds_dn = "CN=NTDS Settings,CN=%s,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,%s" % (names.hostname, names.domaindn)
                 names.ntdsguid = samdb.searchone(basedn=ntds_dn,
@@ -1134,9 +1179,10 @@ def provision(setup_dir, message, session_info,
               domainsid=None, adminpass=None, ldapadminpass=None, 
               krbtgtpass=None, domainguid=None, 
               policyguid=None, policyguid_dc=None, invocationid=None,
-              machinepass=None, 
+              machinepass=None, ntdsguid=None,
               dnspass=None, root=None, nobody=None, users=None, 
-              wheel=None, backup=None, aci=None, serverrole=None, 
+              wheel=None, backup=None, aci=None, serverrole=None,
+              dom_for_fun_level=None,
               ldap_backend_extra_port=None, ldap_backend_type=None,
               sitename=None,
               ol_mmr_urls=None, ol_olc=None, 
@@ -1155,7 +1201,6 @@ def provision(setup_dir, message, session_info,
     else:
       domainsid = security.dom_sid(domainsid)
 
-
     # create/adapt the group policy GUIDs
     if policyguid is None:
         policyguid = str(uuid.uuid4())
@@ -1274,6 +1319,9 @@ def provision(setup_dir, message, session_info,
     setup_registry(paths.hklm, setup_path, session_info, 
                    lp=lp)
 
+    message("Setting up the privileges database")
+    setup_privileges(paths.privilege, setup_path, session_info, lp=lp)
+
     message("Setting up idmap db")
     idmap = setup_idmapdb(paths.idmapdb, setup_path, session_info=session_info,
                           lp=lp)
@@ -1288,8 +1336,10 @@ def provision(setup_dir, message, session_info,
                         fill=samdb_fill, 
                         adminpass=adminpass, krbtgtpass=krbtgtpass,
                         invocationid=invocationid, 
-                        machinepass=machinepass, dnspass=dnspass,
-                        serverrole=serverrole, ldap_backend=provision_backend)
+                        machinepass=machinepass, dnspass=dnspass, 
+                        ntdsguid=ntdsguid, serverrole=serverrole,
+                        dom_for_fun_level=dom_for_fun_level,
+                        ldap_backend=provision_backend)
 
     if serverrole == "domain controller":
         if paths.netlogon is None:
@@ -1352,9 +1402,9 @@ def provision(setup_dir, message, session_info,
             assert isinstance(domainguid, str)
 
             create_zone_file(paths.dns, setup_path, dnsdomain=names.dnsdomain,
-                             domaindn=names.domaindn, hostip=hostip,
+                             hostip=hostip,
                              hostip6=hostip6, hostname=names.hostname,
-                             dnspass=dnspass, realm=names.realm,
+                             realm=names.realm,
                              domainguid=domainguid, ntdsguid=names.ntdsguid)
 
             create_named_conf(paths.namedconf, setup_path, realm=names.realm,
@@ -1897,6 +1947,44 @@ def provision_fds_backend(result, paths=None, setup_path=None, names=None,
                {"SAMBADN": names.sambadn,
                 })
 
+    setup_file(setup_path("fedorads-pam.ldif"), paths.fedoradspam)
+
+    lnkattr = get_linked_attributes(names.schemadn,schema.ldb)
+
+    refint_config = data = open(setup_path("fedorads-refint-delete.ldif"), 'r').read()
+    memberof_config = ""
+    index_config = ""
+    argnum = 3
+
+    for attr in lnkattr.keys():
+        if lnkattr[attr] is not None:
+            refint_config += read_and_sub_file(setup_path("fedorads-refint-add.ldif"),
+                                                 { "ARG_NUMBER" : str(argnum) ,
+                                                   "LINK_ATTR" : attr })
+            memberof_config += read_and_sub_file(setup_path("fedorads-linked-attributes.ldif"),
+                                                 { "MEMBER_ATTR" : attr ,
+                                                   "MEMBEROF_ATTR" : lnkattr[attr] })
+            index_config += read_and_sub_file(setup_path("fedorads-index.ldif"),
+                                                 { "ATTR" : attr })
+            argnum += 1
+
+    open(paths.fedoradsrefint, 'w').write(refint_config)
+    open(paths.fedoradslinkedattributes, 'w').write(memberof_config)
+
+    attrs = ["lDAPDisplayName"]
+    res = schema.ldb.search(expression="(&(objectclass=attributeSchema)(searchFlags:1.2.840.113556.1.4.803:=1))", base=names.schemadn, scope=SCOPE_ONELEVEL, attrs=attrs)
+
+    for i in range (0, len(res)):
+        attr = res[i]["lDAPDisplayName"][0]
+
+        if attr == "objectGUID":
+            attr = "nsUniqueId"
+
+        index_config += read_and_sub_file(setup_path("fedorads-index.ldif"),
+                                             { "ATTR" : attr })
+
+    open(paths.fedoradsindex, 'w').write(index_config)
+
     setup_file(setup_path("fedorads-samba.ldif"), paths.fedoradssamba,
                 {"SAMBADN": names.sambadn, 
                  "LDAPADMINPASS": ldapadminpass
@@ -1957,8 +2045,8 @@ def create_phpldapadmin_config(path, setup_path, ldapi_uri):
             {"S4_LDAPI_URI": ldapi_uri})
 
 
-def create_zone_file(path, setup_path, dnsdomain, domaindn, 
-                     hostip, hostip6, hostname, dnspass, realm, domainguid,
+def create_zone_file(path, setup_path, dnsdomain, 
+                     hostip, hostip6, hostname, realm, domainguid,
                      ntdsguid):
     """Write out a DNS zone file, from the info in the current database.
 
@@ -1969,7 +2057,6 @@ def create_zone_file(path, setup_path, dnsdomain, domaindn,
     :param hostip: Local IPv4 IP
     :param hostip6: Local IPv6 IP
     :param hostname: Local hostname
-    :param dnspass: Password for DNS
     :param realm: Realm name
     :param domainguid: GUID of the domain.
     :param ntdsguid: GUID of the hosts nTDSDSA record.
@@ -1991,7 +2078,6 @@ def create_zone_file(path, setup_path, dnsdomain, domaindn,
         hostip_host_line = ""
 
     setup_file(setup_path("provision.zone"), path, {
-            "DNSPASS_B64": b64encode(dnspass),
             "HOSTNAME": hostname,
             "DNSDOMAIN": dnsdomain,
             "REALM": realm,

diff --git a/source4/scripting/python/samba/tests/samdb.py b/source4/scripting/python/samba/tests/samdb.py
index 8c7bb0ae981c4f6d3528fd3bae670c9f34a7e0b5..d56f75b31404ca557aef44c4cf3e94249c20ba95 100644 (file)
--- a/source4/scripting/python/samba/tests/samdb.py
+++ b/source4/scripting/python/samba/tests/samdb.py
@@ -19,7 +19,7 @@
 from samba.auth import system_session
 from samba.credentials import Credentials
 import os
-from samba.provision import setup_samdb, guess_names, setup_templatesdb, make_smbconf, find_setup_dir
+from samba.provision import setup_samdb, guess_names, make_smbconf, find_setup_dir
 from samba.samdb import SamDB
 from samba.tests import TestCaseInTempDir
 from samba.dcerpc import security
@@ -71,8 +71,6 @@ class SamDBTestCase(TestCaseInTempDir):
                             serverrole=serverrole, 
                             domaindn=self.domaindn, configdn=configdn, 
                             schemadn=schemadn)
-        setup_templatesdb(os.path.join(self.tempdir, "templates.ldb"), 
-                          self.setup_path, session_info=session_info, lp=self.lp)
         self.samdb = setup_samdb(path, self.setup_path, session_info, creds, 
                                  self.lp, names, 
                                  lambda x: None, domainsid, 
@@ -82,7 +80,7 @@ class SamDBTestCase(TestCaseInTempDir):
                                  "secret", "domain controller")
 
     def tearDown(self):
-        for f in ['templates.ldb', 'schema.ldb', 'configuration.ldb', 
+        for f in ['schema.ldb', 'configuration.ldb',
                   'users.ldb', 'samdb.ldb', 'smb.conf']:
             os.remove(os.path.join(self.tempdir, f))
         super(SamDBTestCase, self).tearDown()

diff --git a/source4/selftest/knownfail b/source4/selftest/knownfail
index fcb16c98145a8404afb030403919dc3100f9e5c3..5061171d1e3b34d40656b3758a0664d337d9210a 100644 (file)
--- a/source4/selftest/knownfail
+++ b/source4/selftest/knownfail
@@ -58,3 +58,8 @@ samba4.winbind.struct.*.LOOKUP_NAME_SID   # Not yet working in winbind
 ^samba4.ldap.python \(dc\).Test add_ldif\(\) with BASE64 security descriptor input using WRONG domain SID$
 ^samba4.ldap.python \(dc\).Testing ldb.add_ldif\(\) for nTSecurityDescriptor
 ^samba4.ldap.secdesc.python
+# some operations don't work over the CIFS NTVFS backend yet (eg. root_fid)
+samba4.ntvfs.cifs.base.createx_access 
+samba4.ntvfs.cifs.base.createx_sharemodes_dir
+samba4.ntvfs.cifs.base.maximum_allowed
+samba4.base.createx_access # this test is broken for non-administrator users

diff --git a/source4/selftest/skip b/source4/selftest/skip
index aa57c6b1b4ae8d43501df0eae1da518a0dfe6305..38620b06b683cef9d3da9dd4c1e035c9128a68e3 100644 (file)
--- a/source4/selftest/skip
+++ b/source4/selftest/skip
@@ -20,7 +20,7 @@ base.iometer
 base.casetable
 base.nttrans
 base.scan.maxfid
-raw.hold.oplock                # Not a test, but a way to block other clients for a test
+hold.oplock            # Not a test, but a way to block other clients for a test
 raw.ping.pong          # Needs second server to test
 rpc.samr.accessmask
 raw.scan.eamax
@@ -64,3 +64,5 @@ raw.offline                   # Samba 4 doesn't have much offline support yet
 rpc.autoidl  # this one just generates a lot of noise, and is no longer useful
 samba4.rpc.countcalls # this is not useful now we have full IDL
 samba4.rap.scan # same thing here - we have docs now
+samba4.gensec.python # not finished
+bench # don't run benchmarks in our selftest

diff --git a/source4/setup/domainlevel b/source4/setup/domainlevel
index ceab735c8f88e3e83b099eeea28db3bae66ba16a..c37d811dd8367574fdecbbb153dcc9c4652a6d5c 100755 (executable)
--- a/source4/setup/domainlevel
+++ b/source4/setup/domainlevel
@@ -18,6 +18,11 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+# Notice: At the moment we have some more checks to do here on the special
+# attributes (consider attribute "msDS-Behavior-Version). This is due to the
+# fact that we on s4 LDB don't implement their change policy (only certain
+# values, only increments possible...) yet.
+
 import sys
 
 # Find right directory when running from source tree
@@ -32,6 +37,8 @@ from samba.samdb import SamDB
 from samba import DS_DOMAIN_FUNCTION_2000, DS_DOMAIN_FUNCTION_2003
 from samba import DS_DOMAIN_FUNCTION_2003_MIXED, DS_DOMAIN_FUNCTION_2008
 from samba import DS_DOMAIN_FUNCTION_2008_R2
+from samba import DS_DC_FUNCTION_2000, DS_DC_FUNCTION_2003, DS_DC_FUNCTION_2008
+from samba import DS_DC_FUNCTION_2008_R2
 
 parser = optparse.OptionParser("domainlevel (show | raise <options>)")
 sambaopts = options.SambaOptions(parser)
@@ -41,10 +48,12 @@ credopts = options.CredentialsOptions(parser)
 parser.add_option_group(credopts)
 parser.add_option("-H", help="LDB URL for database or target server", type=str)
 parser.add_option("--quiet", help="Be quiet", action="store_true")
-parser.add_option("--forest",
-  help="The forest function level (2000 | 2003 | 2008 | 2008_R2). We don't support the 2003 with mixed domains (NT4 DC support) level.", type=str)
-parser.add_option("--domain",
-  help="The domain function level (2000 | 2003 | 2008 | 2008_R2). We don't support mixed/interim (NT4 DC support) levels.", type=str)
+parser.add_option("--forest", type="choice",
+  choices=["2003", "2008", "2008_R2"],
+  help="The forest function level (2003 | 2008 | 2008_R2)")
+parser.add_option("--domain", type="choice",
+  choices=["2003", "2008", "2008_R2"],
+  help="The domain function level (2003 | 2008 | 2008_R2)")
 opts, args = parser.parse_args()
 
 #
@@ -78,29 +87,48 @@ res_domain = samdb.search(domain_dn, scope=ldb.SCOPE_BASE,
   attrs=["msDS-Behavior-Version", "nTMixedDomain"])
 assert(len(res_domain) == 1)
 
+res_dc_s = samdb.search("CN=Sites,CN=Configuration," + domain_dn,
+  scope=ldb.SCOPE_SUBTREE, expression="(objectClass=nTDSDSA)",
+  attrs=["msDS-Behavior-Version"])
+assert(len(res_dc_s) >= 1)
+
 try:
        level_forest = int(res_forest[0]["msDS-Behavior-Version"][0])
        level_domain = int(res_domain[0]["msDS-Behavior-Version"][0])
        level_domain_mixed = int(res_domain[0]["nTMixedDomain"][0])
 
+       min_level_dc = int(res_dc_s[0]["msDS-Behavior-Version"][0]) # Init value
+       for msg in res_dc_s:
+               if int(msg["msDS-Behavior-Version"][0]) < min_level_dc:
+                       min_level_dc = int(msg["msDS-Behavior-Version"][0])
+
        if level_forest < 0 or level_domain < 0:
-               print "ERROR: Domain and/or forest functional level(s) is/are invalid. Correct them or reprovision!"
+               print >>sys.stderr, "ERROR: Domain and/or forest function level(s) is/are invalid. Correct them or reprovision!"
+               sys.exit(1)
+       if min_level_dc < 0:
+               print >>sys.stderr, "ERROR: Lowest function level of a DC is invalid. Correct this or reprovision!"
                sys.exit(1)
        if level_forest > level_domain:
-               print "ERROR: Forest function level is higher than the domain level(s). That can't be. Correct this or reprovision!"
+               print >>sys.stderr, "ERROR: Forest function level is higher than the domain level(s). Correct this or reprovision!"
+               sys.exit(1)
+       if level_domain > min_level_dc:
+               print >>sys.stderr, "ERROR: Domain function level is higher than the lowest function level of a DC. Correct this or reprovision!"
                sys.exit(1)
-except:
-       print "ERROR: Could not retrieve the actual domain and/or forest level!"
+
+except KeyError:
+       print >>sys.stderr, "ERROR: Could not retrieve the actual domain, forest level and/or lowest DC function level!"
        if args[0] == "show":
-               print "So the levels can't be displayed!"
+               print >>sys.stderr, "So the levels can't be displayed!"
        sys.exit(1)
 
 if args[0] == "show":
        message("Domain and forest function level for domain '" + domain_dn + "'")
-       if level_forest == DS_DOMAIN_FUNCTION_2003_MIXED:
-               message("\nATTENTION: You run SAMBA 4 on the 2003 with mixed domains (NT4 DC support) forest level. This isn't supported! Please raise!")
-       if (level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0) or level_domain == DS_DOMAIN_FUNCTION_2003_MIXED:
-               message("\nATTENTION: You run SAMBA 4 on a mixed/interim (NT4 DC support) domain level. This isn't supported! Please raise!")
+       if level_forest < DS_DOMAIN_FUNCTION_2003:
+               message("\nATTENTION: You run SAMBA 4 on a forest function level lower than Windows 2003 (Native). This isn't supported! Please raise!")
+       if level_domain < DS_DOMAIN_FUNCTION_2003:
+               message("\nATTENTION: You run SAMBA 4 on a domain function level lower than Windows 2003 (Native). This isn't supported! Please raise!")
+       if min_level_dc < DS_DC_FUNCTION_2003:
+               message("\nATTENTION: You run SAMBA 4 on a lowest function level of a DC lower than Windows 2003. This isn't supported! Please step-up or upgrade the concerning DC(s)!")
 
        message("")
 
@@ -134,26 +162,37 @@ if args[0] == "show":
                outstr = "higher than 2008 R2"
        message("Domain function level: (Windows) " + outstr)
 
+       if min_level_dc == DS_DC_FUNCTION_2000:
+               outstr = "2000"
+       elif min_level_dc == DS_DC_FUNCTION_2003:
+               outstr = "2003"
+       elif min_level_dc == DS_DC_FUNCTION_2008:
+               outstr = "2008"
+       elif min_level_dc == DS_DC_FUNCTION_2008_R2:
+               outstr = "2008 R2"
+       else:
+               outstr = "higher than 2008 R2"
+       message("Lowest function level of a DC: (Windows) " + outstr)
+
 elif args[0] == "raise":
        msgs = []
 
        if opts.domain is not None:
                arg = opts.domain
 
-               if arg == "2000":
-                       new_level_domain = DS_DOMAIN_FUNCTION_2000      
-               elif arg == "2003":
+               if arg == "2003":
                        new_level_domain = DS_DOMAIN_FUNCTION_2003
                elif arg == "2008":
                        new_level_domain = DS_DOMAIN_FUNCTION_2008
                elif arg == "2008_R2":
                        new_level_domain = DS_DOMAIN_FUNCTION_2008_R2
-               else:
-                       print "ERROR: Wrong argument '" + arg + "'!"
-                       sys.exit(1)
 
                if new_level_domain <= level_domain and level_domain_mixed == 0:
-                       print "ERROR: Domain function level can't be smaller equal to the actual one!"
+                       print >>sys.stderr, "ERROR: Domain function level can't be smaller equal to the actual one!"
+                       sys.exit(1)
+
+               if new_level_domain > min_level_dc:
+                       print >>sys.stderr, "ERROR: Domain function level can't be higher than the lowest function level of a DC!"
                        sys.exit(1)
 
                # Deactivate mixed/interim domain support
@@ -178,24 +217,19 @@ elif args[0] == "raise":
        if opts.forest is not None:
                arg = opts.forest
 
-               if arg == "2000":
-                       new_level_forest = DS_DOMAIN_FUNCTION_2000      
-               elif arg == "2003":
+               if arg == "2003":
                        new_level_forest = DS_DOMAIN_FUNCTION_2003
                elif arg == "2008":
                        new_level_forest = DS_DOMAIN_FUNCTION_2008
                elif arg == "2008_R2":
                        new_level_forest = DS_DOMAIN_FUNCTION_2008_R2
-               else:
-                       print "ERROR: Wrong argument '" + arg + "'!"
-                       sys.exit(1)
 
                if new_level_forest <= level_forest:
-                       print "ERROR: Forest function level can't be smaller equal to the actual one!"
+                       print >>sys.stderr, "ERROR: Forest function level can't be smaller equal to the actual one!"
                        sys.exit(1)
 
                if new_level_forest > level_domain:
-                       print "ERROR: Forest function level can't be higher than the domain function level(s). Please raise it/them first!"
+                       print >>sys.stderr, "ERROR: Forest function level can't be higher than the domain function level(s). Please raise it/them first!"
                        sys.exit(1)
 
                m = ldb.Message()
@@ -212,5 +246,5 @@ elif args[0] == "raise":
 
        message("\n".join(msgs))
 else:
-       print "ERROR: Wrong argument '" + args[0] + "'!"
+       print >>sys.stderr, "ERROR: Wrong argument '" + args[0] + "'!"
        sys.exit(1)

diff --git a/source4/setup/fedorads-index.ldif b/source4/setup/fedorads-index.ldif
new file mode 100644 (file)
index 0000000..4b4eb23
--- /dev/null
+++ b/source4/setup/fedorads-index.ldif
@@ -0,0 +1,7 @@
+dn: cn=${ATTR},cn=default indexes,cn=config,cn=ldbm database,cn=plugins,cn=config
+objectClass: top
+objectClass: nsIndex
+cn: ${ATTR}
+nsSystemIndex: false
+nsIndexType: eq
+

diff --git a/source4/setup/fedorads-linked-attributes.ldif b/source4/setup/fedorads-linked-attributes.ldif
new file mode 100644 (file)
index 0000000..05abcf9
--- /dev/null
+++ b/source4/setup/fedorads-linked-attributes.ldif
@@ -0,0 +1,7 @@
+# Link ${MEMBER_ATTR} to ${MEMBEROF_ATTR}
+dn: cn=${MEMBER_ATTR} to ${MEMBEROF_ATTR},cn=Linked Attributes,cn=plugins,cn=config
+objectClass: extensibleObject
+cn: ${MEMBER_ATTR} to ${MEMBEROF_ATTR}
+linkType: ${MEMBER_ATTR}
+managedType: ${MEMBEROF_ATTR}
+

diff --git a/source4/setup/fedorads-pam.ldif b/source4/setup/fedorads-pam.ldif
new file mode 100644 (file)
index 0000000..5ffd5cf
--- /dev/null
+++ b/source4/setup/fedorads-pam.ldif
@@ -0,0 +1,2 @@
+dn: cn=PAM Pass Through Auth,cn=plugins,cn=config
+changetype: delete

diff --git a/source4/setup/fedorads-refint-add.ldif b/source4/setup/fedorads-refint-add.ldif
new file mode 100644 (file)
index 0000000..2deb07d
--- /dev/null
+++ b/source4/setup/fedorads-refint-add.ldif
@@ -0,0 +1,6 @@
+dn: cn=referential integrity postoperation,cn=plugins,cn=config
+changetype: modify
+add: nsslapd-pluginArg${ARG_NUMBER}
+nsslapd-pluginArg${ARG_NUMBER}: ${LINK_ATTR}
+-
+

diff --git a/source4/setup/fedorads-refint-delete.ldif b/source4/setup/fedorads-refint-delete.ldif
new file mode 100644 (file)
index 0000000..cd20b83
--- /dev/null
+++ b/source4/setup/fedorads-refint-delete.ldif
@@ -0,0 +1,20 @@
+dn: cn=referential integrity postoperation,cn=plugins,cn=config
+changetype: modify
+delete: nsslapd-pluginArg3
+-
+
+dn: cn=referential integrity postoperation,cn=plugins,cn=config
+changetype: modify
+delete: nsslapd-pluginArg4
+-
+
+dn: cn=referential integrity postoperation,cn=plugins,cn=config
+changetype: modify
+delete: nsslapd-pluginArg5
+-
+
+dn: cn=referential integrity postoperation,cn=plugins,cn=config
+changetype: modify
+delete: nsslapd-pluginArg6
+-
+

diff --git a/source4/setup/fedorads.inf b/source4/setup/fedorads.inf
index 90ebe6a9a5ec0694bbd7631a4efe68650b89dab1..e0676c41df9fb55be09d2ffa8cff900b376e0691 100644 (file)
--- a/source4/setup/fedorads.inf
+++ b/source4/setup/fedorads.inf
@@ -28,3 +28,7 @@ install_full_schema= 0
 SchemaFile=${LDAPDIR}/99_ad.ldif
 ConfigFile = ${LDAPDIR}/fedorads-partitions.ldif
 ConfigFile = ${LDAPDIR}/fedorads-sasl.ldif
+ConfigFile = ${LDAPDIR}/fedorads-pam.ldif
+ConfigFile = ${LDAPDIR}/fedorads-refint.ldif
+ConfigFile = ${LDAPDIR}/fedorads-linked-attributes.ldif
+ConfigFile = ${LDAPDIR}/fedorads-index.ldif

diff --git a/source4/setup/provision b/source4/setup/provision
index 8bf08b9e39892d16c9a56c5e95316674ffa09d35..1cfcfc7137c3d7b05034a860291feeef2b814d04 100755 (executable)
--- a/source4/setup/provision
+++ b/source4/setup/provision
@@ -93,7 +93,10 @@ parser.add_option("--ldap-backend-type", type="choice", metavar="LDAP-BACKEND-TY
 parser.add_option("--ldap-backend-nosync", help="Configure LDAP backend not to call fsync() (for performance in test environments)", action="store_true")
 parser.add_option("--server-role", type="choice", metavar="ROLE",
                  choices=["domain controller", "dc", "member server", "member", "standalone"],
-               help="Set server role to provision for (default standalone)")
+               help="The server role (domain controller | dc | member server | member | standalone). Default is standalone.")
+parser.add_option("--function-level", type="choice", metavar="FOR-FUN-LEVEL",
+                 choices=["2003", "2008", "2008_R2"],
+               help="The domain and forest function level (2003 | 2008 | 2008_R2). Default is (Windows) 2003 (Native).")
 parser.add_option("--partitions-only", 
                help="Configure Samba's partitions, but do not modify them (ie, join a BDC)", action="store_true")
 parser.add_option("--targetdir", type="string", metavar="DIR", 
@@ -164,6 +167,15 @@ elif opts.server_role == "member":
 else:
        server_role = opts.server_role
 
+if opts.function_level is None:
+       dom_for_fun_level = None
+elif opts.function_level == "2003":
+       dom_for_fun_level = DS_DOMAIN_FUNCTION_2003
+elif opts.function_level == "2008":
+       dom_for_fun_level = DS_DOMAIN_FUNCTION_2008
+elif opts.function_level == "2008_R2":
+       dom_for_fun_level = DS_DOMAIN_FUNCTION_2008_R2
+
 creds = credopts.get_credentials(lp)
 
 creds.set_kerberos_state(DONT_USE_KERBEROS)
@@ -190,12 +202,9 @@ provision(setup_dir, message,
           krbtgtpass=opts.krbtgtpass, machinepass=opts.machinepass,
           dnspass=opts.dnspass, root=opts.root, nobody=opts.nobody,
           wheel=opts.wheel, users=opts.users,
-          serverrole=server_role, 
+          serverrole=server_role, dom_for_fun_level=dom_for_fun_level,
           ldap_backend_extra_port=opts.ldap_backend_extra_port, 
           ldap_backend_type=opts.ldap_backend_type,
-         ldapadminpass=opts.ldapadminpass,
-         ol_mmr_urls=opts.ol_mmr_urls,
-         slapd_path=opts.slapd_path,
-         setup_ds_path=opts.setup_ds_path,
-         nosync=opts.nosync,
-         ldap_dryrun_mode=opts.ldap_dryrun_mode)
+          ldapadminpass=opts.ldapadminpass, ol_mmr_urls=opts.ol_mmr_urls,
+          slapd_path=opts.slapd_path, setup_ds_path=opts.setup_ds_path,
+          nosync=opts.nosync,ldap_dryrun_mode=opts.ldap_dryrun_mode)

diff --git a/source4/setup/provision.ldif b/source4/setup/provision.ldif
index 0e30efc6172d6c67739a240c228f2d7db246e296..395d4042687ba5fd63d659666f88c1a7e2c7163b 100644 (file)
--- a/source4/setup/provision.ldif
+++ b/source4/setup/provision.ldif
@@ -137,6 +137,11 @@ dn: CN=DomainUpdates,CN=System,${DOMAINDN}
 objectClass: top
 objectClass: container
 
+dn: CN=ActiveDirectoryUpdate,CN=DomainUpdates,CN=System,${DOMAINDN}
+objectClass: top
+objectClass: container
+revision: 5
+
 dn: CN=Operations,CN=DomainUpdates,CN=System,${DOMAINDN}
 objectClass: top
 objectClass: container

diff --git a/source4/setup/provision_basedn.ldif b/source4/setup/provision_basedn.ldif
index df34e4bbf084768ca3f3979eac3c2682b8d0ffc0..eea8d4f148fd346eb585b53d49d47ea3cdfed879 100644 (file)
--- a/source4/setup/provision_basedn.ldif
+++ b/source4/setup/provision_basedn.ldif
@@ -3,5 +3,6 @@
 ################################
 dn: ${DOMAINDN}
 objectClass: top
-objectClass: ${DOMAIN_OC}
-
+objectClass: domaindns
+instanceType: 5
+${DOMAINGUID}

diff --git a/source4/setup/provision_basedn_modify.ldif b/source4/setup/provision_basedn_modify.ldif
index 39fd08e0d87d1828fea553e1b3a8825a8064b283..7fc5c6bf86f76fd37b0cb6a4c12cf323f8b91351 100644 (file)
--- a/source4/setup/provision_basedn_modify.ldif
+++ b/source4/setup/provision_basedn_modify.ldif
@@ -110,4 +110,3 @@ wellKnownObjects: B:32:a361b2ffffd211d1aa4b00c04fd7d83a:OU=Domain Controllers,${
 wellKnownObjects: B:32:aa312825768811d1aded00c04fd8d5cd:CN=Computers,${DOMAINDN}
 wellKnownObjects: B:32:a9d1ca15768811d1aded00c04fd8d5cd:CN=Users,${DOMAINDN}
 -
-${DOMAINGUID_MOD}

diff --git a/source4/setup/provision_configuration.ldif b/source4/setup/provision_configuration.ldif
index 48b4dad98cf5daa38804a9f4ec70bef4dd8a1e63..0716345c4ae06dcd10dc3810b2b4934e6973578f 100644 (file)
--- a/source4/setup/provision_configuration.ldif
+++ b/source4/setup/provision_configuration.ldif
@@ -647,6 +647,16 @@ dn: CN=ForestUpdates,${CONFIGDN}
 objectClass: top
 objectClass: container
 
+dn: CN=ActiveDirectoryRodcUpdate,CN=ForestUpdates,${CONFIGDN}
+objectClass: top
+objectClass: container
+revision: 5
+
+dn: CN=ActiveDirectoryUpdate,CN=ForestUpdates,${CONFIGDN}
+objectClass: top
+objectClass: container
+revision: 5
+
 dn: CN=Operations,CN=ForestUpdates,${CONFIGDN}
 objectClass: top
 objectClass: container

diff --git a/source4/setup/provision_configuration_basedn.ldif b/source4/setup/provision_configuration_basedn.ldif
index b385359a61276bb1477293a0cca5f99e29046868..14a2c332583224d10fdeb2bf7c01d23db1c4d5b8 100644 (file)
--- a/source4/setup/provision_configuration_basedn.ldif
+++ b/source4/setup/provision_configuration_basedn.ldif
@@ -6,3 +6,4 @@ objectClass: top
 objectClass: configuration
 cn: Configuration
 nTSecurityDescriptor:: ${DESCRIPTOR}
+instanceType: 13

diff --git a/source4/setup/provision_privilege.ldif b/source4/setup/provision_privilege.ldif
new file mode 100644 (file)
index 0000000..0916c59
--- /dev/null
+++ b/source4/setup/provision_privilege.ldif
@@ -0,0 +1,78 @@
+# default privileges - more can be added via LSA or ldbedit
+dn: @ATTRIBUTES
+comment: CASE_INSENSITIVE
+privilege: CASE_INSENSITIVE
+
+dn: @INDEXLIST
+@IDXATTR: objectSid
+@IDXATTR: privilege
+
+dn: sid=S-1-5-32-544
+objectClass: privilege
+comment: Administrators
+objectSid: S-1-5-32-544
+privilege: SeSecurityPrivilege
+privilege: SeBackupPrivilege
+privilege: SeRestorePrivilege
+privilege: SeSystemtimePrivilege
+privilege: SeShutdownPrivilege
+privilege: SeRemoteShutdownPrivilege
+privilege: SeTakeOwnershipPrivilege
+privilege: SeDebugPrivilege
+privilege: SeSystemEnvironmentPrivilege
+privilege: SeSystemProfilePrivilege
+privilege: SeProfileSingleProcessPrivilege
+privilege: SeIncreaseBasePriorityPrivilege
+privilege: SeLoadDriverPrivilege
+privilege: SeCreatePagefilePrivilege
+privilege: SeIncreaseQuotaPrivilege
+privilege: SeChangeNotifyPrivilege
+privilege: SeUndockPrivilege
+privilege: SeManageVolumePrivilege
+privilege: SeImpersonatePrivilege
+privilege: SeCreateGlobalPrivilege
+privilege: SeEnableDelegationPrivilege
+privilege: SeInteractiveLogonRight
+privilege: SeNetworkLogonRight
+privilege: SeRemoteInteractiveLogonRight
+
+dn: sid=S-1-5-32-550
+objectClass: privilege
+comment: Print Operators
+objectSid: S-1-5-32-550
+privilege: SeLoadDriverPrivilege
+privilege: SeShutdownPrivilege
+privilege: SeInteractiveLogonRight
+
+dn: sid=S-1-5-32-551
+objectClass: privilege
+comment: Backup Operators
+objectSid: S-1-5-32-551
+privilege: SeBackupPrivilege
+privilege: SeRestorePrivilege
+privilege: SeShutdownPrivilege
+privilege: SeInteractiveLogonRight
+
+dn: sid=S-1-5-32-549
+objectClass: privilege
+comment: Server Operators
+objectSid: S-1-5-32-549
+privilege: SeBackupPrivilege
+privilege: SeSystemtimePrivilege
+privilege: SeRemoteShutdownPrivilege
+privilege: SeRestorePrivilege
+privilege: SeShutdownPrivilege
+privilege: SeInteractiveLogonRight
+
+dn: sid=S-1-5-32-548
+objectClass: privilege
+comment: Account Operators
+objectSid: S-1-5-32-548
+privilege: SeInteractiveLogonRight
+
+dn: sid=S-1-5-32-554
+objectClass: privilege
+comment: Pre-Windows 2000 Compatible Access
+objectSid: S-1-5-32-554
+privilege: SeRemoteInteractiveLogonRight
+privilege: SeChangeNotifyPrivilege

diff --git a/source4/setup/provision_schema_basedn.ldif b/source4/setup/provision_schema_basedn.ldif
index 5301a11965a23b07de41af5553c26dffed461e42..6fe0b0ea9325b9eb916f5dbb6fbf66753a16ce8d 100644 (file)
--- a/source4/setup/provision_schema_basedn.ldif
+++ b/source4/setup/provision_schema_basedn.ldif
@@ -6,3 +6,4 @@ objectClass: top
 objectClass: dMD
 cn: Schema
 nTSecurityDescriptor:: ${DESCRIPTOR}
+instanceType: 13

diff --git a/source4/setup/provision_schema_basedn_modify.ldif b/source4/setup/provision_schema_basedn_modify.ldif
index 07a7dad320a2f77bac22c2a58e930608281179bd..93266db6249bd46b58b62f6c3cd6b78d1e40e0da 100644 (file)
--- a/source4/setup/provision_schema_basedn_modify.ldif
+++ b/source4/setup/provision_schema_basedn_modify.ldif
@@ -6,5 +6,5 @@ changetype: modify
 -
 # "masteredBy", "msDs-masteredBy" filled in later
 replace: objectVersion
-objectVersion: 30
+objectVersion: 47
 

diff --git a/source4/setup/provision_self_join.ldif b/source4/setup/provision_self_join.ldif
index 639bc9604011ec13d93e27f2a9242a23635212ce..0d28b51a4343935573463e366f6e8c5f3a04a082 100644 (file)
--- a/source4/setup/provision_self_join.ldif
+++ b/source4/setup/provision_self_join.ldif
@@ -67,6 +67,7 @@ msDS-hasMasterNCs: ${SCHEMADN}
 msDS-hasMasterNCs: ${DOMAINDN}
 options: 1
 systemFlags: 33554432
+${NTDSGUID}
 
 # Provides an account for DNS keytab export
 dn: CN=dns,CN=Users,${DOMAINDN}

diff --git a/source4/setup/provision_users.ldif b/source4/setup/provision_users.ldif
index bc5616ba5b671c031782d6ca1182e8d04e5d52e8..161d3052297f68b18089ce8ee395fa44a58707da 100644 (file)
--- a/source4/setup/provision_users.ldif
+++ b/source4/setup/provision_users.ldif
@@ -1,5 +1,6 @@
-# Add default primary groups (domain users, domain guests) - needed for
-# the users to find valid primary groups (samldb module)
+# Add default primary groups (domain users, domain guests, domain computers &
+# domain controllers) - needed for the users to find valid primary groups
+# (samldb module)
 
 dn: CN=Domain Users,CN=Users,${DOMAINDN}
 objectClass: top
@@ -17,6 +18,23 @@ objectSid: ${DOMAINSID}-514
 sAMAccountName: Domain Guests
 isCriticalSystemObject: TRUE
 
+dn: CN=Domain Computers,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+description: All workstations and servers joined to the domain
+objectSid: ${DOMAINSID}-515
+sAMAccountName: Domain Computers
+isCriticalSystemObject: TRUE
+
+dn: CN=Domain Controllers,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+description: All domain controllers in the domain
+objectSid: ${DOMAINSID}-516
+adminCount: 1
+sAMAccountName: Domain Controllers
+isCriticalSystemObject: TRUE
+
 # Add users
 
 dn: CN=Administrator,CN=Users,${DOMAINDN}
@@ -67,23 +85,6 @@ adminCount: 1
 sAMAccountName: Enterprise Admins
 isCriticalSystemObject: TRUE
 
-dn: CN=Domain Computers,CN=Users,${DOMAINDN}
-objectClass: top
-objectClass: group
-description: All workstations and servers joined to the domain
-objectSid: ${DOMAINSID}-515
-sAMAccountName: Domain Computers
-isCriticalSystemObject: TRUE
-
-dn: CN=Domain Controllers,CN=Users,${DOMAINDN}
-objectClass: top
-objectClass: group
-description: All domain controllers in the domain
-objectSid: ${DOMAINSID}-516
-adminCount: 1
-sAMAccountName: Domain Controllers
-isCriticalSystemObject: TRUE
-
 dn: CN=Schema Admins,CN=Users,${DOMAINDN}
 objectClass: top
 objectClass: group
@@ -212,30 +213,6 @@ adminCount: 1
 sAMAccountName: Administrators
 systemFlags: -1946157056
 groupType: -2147483643
-privilege: SeSecurityPrivilege
-privilege: SeBackupPrivilege
-privilege: SeRestorePrivilege
-privilege: SeSystemtimePrivilege
-privilege: SeShutdownPrivilege
-privilege: SeRemoteShutdownPrivilege
-privilege: SeTakeOwnershipPrivilege
-privilege: SeDebugPrivilege
-privilege: SeSystemEnvironmentPrivilege
-privilege: SeSystemProfilePrivilege
-privilege: SeProfileSingleProcessPrivilege
-privilege: SeIncreaseBasePriorityPrivilege
-privilege: SeLoadDriverPrivilege
-privilege: SeCreatePagefilePrivilege
-privilege: SeIncreaseQuotaPrivilege
-privilege: SeChangeNotifyPrivilege
-privilege: SeUndockPrivilege
-privilege: SeManageVolumePrivilege
-privilege: SeImpersonatePrivilege
-privilege: SeCreateGlobalPrivilege
-privilege: SeEnableDelegationPrivilege
-privilege: SeInteractiveLogonRight
-privilege: SeNetworkLogonRight
-privilege: SeRemoteInteractiveLogonRight
 isCriticalSystemObject: TRUE
 
 dn: CN=Users,CN=Builtin,${DOMAINDN}
@@ -272,9 +249,6 @@ adminCount: 1
 sAMAccountName: Print Operators
 systemFlags: -1946157056
 groupType: -2147483643
-privilege: SeLoadDriverPrivilege
-privilege: SeShutdownPrivilege
-privilege: SeInteractiveLogonRight
 isCriticalSystemObject: TRUE
 
 dn: CN=Backup Operators,CN=Builtin,${DOMAINDN}
@@ -286,10 +260,6 @@ adminCount: 1
 sAMAccountName: Backup Operators
 systemFlags: -1946157056
 groupType: -2147483643
-privilege: SeBackupPrivilege
-privilege: SeRestorePrivilege
-privilege: SeShutdownPrivilege
-privilege: SeInteractiveLogonRight
 isCriticalSystemObject: TRUE
 
 dn: CN=Replicator,CN=Builtin,${DOMAINDN}
@@ -353,12 +323,6 @@ adminCount: 1
 sAMAccountName: Server Operators
 systemFlags: -1946157056
 groupType: -2147483643
-privilege: SeBackupPrivilege
-privilege: SeSystemtimePrivilege
-privilege: SeRemoteShutdownPrivilege
-privilege: SeRestorePrivilege
-privilege: SeShutdownPrivilege
-privilege: SeInteractiveLogonRight
 isCriticalSystemObject: TRUE
 
 dn: CN=Account Operators,CN=Builtin,${DOMAINDN}
@@ -370,7 +334,6 @@ adminCount: 1
 sAMAccountName: Account Operators
 systemFlags: -1946157056
 groupType: -2147483643
-privilege: SeInteractiveLogonRight
 isCriticalSystemObject: TRUE
 
 dn: CN=Pre-Windows 2000 Compatible Access,CN=Builtin,${DOMAINDN}
@@ -382,8 +345,6 @@ objectSid: S-1-5-32-554
 sAMAccountName: Pre-Windows 2000 Compatible Access
 systemFlags: -1946157056
 groupType: -2147483643
-privilege: SeRemoteInteractiveLogonRight
-privilege: SeChangeNotifyPrivilege
 isCriticalSystemObject: TRUE
 
 dn: CN=Incoming Forest Trust Builders,CN=Builtin,${DOMAINDN}

diff --git a/source4/setup/pwsettings b/source4/setup/pwsettings
index 0bb39d975761f7f5755acee3b4957eb89381723a..59ed5d29bf4b6f6a61182472e2aa1c0fa04b8e9a 100755 (executable)
--- a/source4/setup/pwsettings
+++ b/source4/setup/pwsettings
@@ -41,8 +41,8 @@ credopts = options.CredentialsOptions(parser)
 parser.add_option_group(credopts)
 parser.add_option("-H", help="LDB URL for database or target server", type=str)
 parser.add_option("--quiet", help="Be quiet", action="store_true")
-parser.add_option("--complexity",
-  help="The password complexity (on | off | default). Default is 'on'", type=str)
+parser.add_option("--complexity", type="choice", choices=["on","off","default"],
+  help="The password complexity (on | off | default). Default is 'on'")
 parser.add_option("--history-length",
   help="The password history length (<integer> | default).  Default is 24.", type=str)
 parser.add_option("--min-pwd-length",
@@ -87,10 +87,10 @@ try:
        # ticks -> days
        min_pwd_age = int(abs(int(res[0]["minPwdAge"][0])) / (1e7 * 60 * 60 * 24))
        max_pwd_age = int(abs(int(res[0]["maxPwdAge"][0])) / (1e7 * 60 * 60 * 24))
-except:
-       print "ERROR: Could not retrieve password properties!"
+except KeyError:
+       print >>sys.stderr, "ERROR: Could not retrieve password properties!"
        if args[0] == "show":
-               print "So no settings can be displayed!"
+               print >>sys.stderr, "So no settings can be displayed!"
        sys.exit(1)
 
 if args[0] == "show":
@@ -118,9 +118,6 @@ elif args[0] == "set":
                elif opts.complexity == "off":
                        pwd_props = pwd_props & (~DOMAIN_PASSWORD_COMPLEX)
                        msgs.append("Password complexity deactivated!")
-               else:
-                       print "ERROR: Wrong argument '" + opts.complexity + "'!"
-                       sys.exit(1)
 
                m["pwdProperties"] = ldb.MessageElement(str(pwd_props),
                  ldb.FLAG_MOD_REPLACE, "pwdProperties")
@@ -132,7 +129,7 @@ elif args[0] == "set":
                        pwd_hist_len = int(opts.history_length)
 
                if pwd_hist_len < 0 or pwd_hist_len > 24:
-                       print "ERROR: Password history length must be in the range of 0 to 24!"
+                       print >>sys.stderr, "ERROR: Password history length must be in the range of 0 to 24!"
                        sys.exit(1)
 
                m["pwdHistoryLength"] = ldb.MessageElement(str(pwd_hist_len),
@@ -146,7 +143,7 @@ elif args[0] == "set":
                        min_pwd_len = int(opts.min_pwd_length)
 
                if min_pwd_len < 0 or min_pwd_len > 14:
-                       print "ERROR: Minimum password length must be in the range of 0 to 14!"
+                       print >>sys.stderr, "ERROR: Minimum password length must be in the range of 0 to 14!"
                        sys.exit(1)
 
                m["minPwdLength"] = ldb.MessageElement(str(min_pwd_len),
@@ -160,7 +157,7 @@ elif args[0] == "set":
                        min_pwd_age = int(opts.min_pwd_age)
 
                if min_pwd_age < 0 or min_pwd_age > 998:
-                       print "ERROR: Minimum password age must be in the range of 0 to 998!"
+                       print >>sys.stderr, "ERROR: Minimum password age must be in the range of 0 to 998!"
                        sys.exit(1)
 
                # days -> ticks
@@ -177,7 +174,7 @@ elif args[0] == "set":
                        max_pwd_age = int(opts.max_pwd_age)
 
                if max_pwd_age < 0 or max_pwd_age > 999:
-                       print "ERROR: Maximum password age must be in the range of 0 to 999!"
+                       print >>sys.stderr, "ERROR: Maximum password age must be in the range of 0 to 999!"
                        sys.exit(1)
 
                # days -> ticks
@@ -197,5 +194,5 @@ elif args[0] == "set":
 
        message("\n".join(msgs))
 else:
-       print "ERROR: Wrong argument '" + args[0] + "'!"
+       print >>sys.stderr, "ERROR: Wrong argument '" + args[0] + "'!"
        sys.exit(1)

diff --git a/source4/setup/schema_samba4.ldif b/source4/setup/schema_samba4.ldif
index f447bf5617f784a0c67643e7f9285891e3c43a2f..76b31f0cd74466611275d1d4a6f1e6d5b5e39164 100644 (file)
--- a/source4/setup/schema_samba4.ldif
+++ b/source4/setup/schema_samba4.ldif
@@ -121,19 +121,20 @@
 #attributeSyntax: 2.5.5.4
 #oMSyntax: 20
 
-dn: cn=privilege,${SCHEMADN}
-objectClass: top
-objectClass: attributeSchema
-cn: privilege
-lDAPDisplayName: privilege
-isSingleValued: FALSE
-systemFlags: 17
-systemOnly: TRUE
-schemaIDGUID: 7429BC94-CC6A-4481-8B2C-A97E316EB182
-adminDisplayName: Privilege
-attributeID: 1.3.6.1.4.1.7165.4.1.7
-attributeSyntax: 2.5.5.4
-oMSyntax: 20
+# not used anymore
+#dn: cn=privilege,${SCHEMADN}
+#objectClass: top
+#objectClass: attributeSchema
+#cn: privilege
+#lDAPDisplayName: privilege
+#isSingleValued: FALSE
+#systemFlags: 17
+#systemOnly: TRUE
+#schemaIDGUID: 7429BC94-CC6A-4481-8B2C-A97E316EB182
+#adminDisplayName: Privilege
+#attributeID: 1.3.6.1.4.1.7165.4.1.7
+#attributeSyntax: 2.5.5.4
+#oMSyntax: 20
 
 #
 # Not used anymore
@@ -197,26 +198,29 @@ oMSyntax: 20
 # Based on domainDNS, but without the DNS bits.
 #
 
-dn: CN=Samba4-Local-Domain,${SCHEMADN}
-objectClass: top
-objectClass: classSchema
-cn: Samba4-Local-Domain
-subClassOf: top
-governsID: 1.3.6.1.4.1.7165.4.2.2
-rDNAttID: cn
-adminDisplayName: Samba4-Local-Domain
-adminDescription: Samba4-Local-Domain
-systemMayContain: msDS-Behavior-Version
-systemMayContain: managedBy
-objectClassCategory: 1
-lDAPDisplayName: samba4LocalDomain
-schemaIDGUID: 07be1647-8310-4fba-91ae-34e55d5a8293
-systemOnly: FALSE
-systemAuxiliaryClass: samDomain
-defaultSecurityDescriptor: D:(A;;RPLCLORC;;;DA)(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)(A;;RPLCLORC;;;AU)
-systemFlags: 16
-defaultHidingValue: TRUE
-defaultObjectCategory: CN=Samba4-Local-Domain,${SCHEMADN}
+#
+# Not used anymore
+#
+#dn: CN=Samba4-Local-Domain,${SCHEMADN}
+#objectClass: top
+#objectClass: classSchema
+#cn: Samba4-Local-Domain
+#subClassOf: top
+#governsID: 1.3.6.1.4.1.7165.4.2.2
+#rDNAttID: cn
+#adminDisplayName: Samba4-Local-Domain
+#adminDescription: Samba4-Local-Domain
+#systemMayContain: msDS-Behavior-Version
+#systemMayContain: managedBy
+#objectClassCategory: 1
+#lDAPDisplayName: samba4LocalDomain
+#schemaIDGUID: 07be1647-8310-4fba-91ae-34e55d5a8293
+#systemOnly: FALSE
+#systemAuxiliaryClass: samDomain
+#defaultSecurityDescriptor: D:(A;;RPLCLORC;;;DA)(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)(A;;RPLCLORC;;;AU)
+#systemFlags: 16
+#defaultHidingValue: TRUE
+#defaultObjectCategory: CN=Samba4-Local-Domain,${SCHEMADN}
 
 
 dn: CN=Samba4Top,${SCHEMADN}
@@ -313,32 +317,9 @@ systemMayContain: adminDescription
 systemMustContain: objectCategory
 systemMustContain: nTSecurityDescriptor
 systemMustContain: instanceType
-systemAuxiliaryClass: samba4TopExtra
 defaultSecurityDescriptor: D:(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)(A;;RPLCLORC;;;AU)
 systemFlags: 16
 defaultHidingValue: TRUE
 objectCategory: CN=Class-Schema,${SCHEMADN}
 defaultObjectCategory: CN=Samba4Top,${SCHEMADN}
 
-
-dn: CN=Samba4TopExtra,${SCHEMADN}
-objectClass: top
-objectClass: classSchema
-cn: Samba4TopExtra
-subClassOf: top
-governsID: 1.3.6.1.4.1.7165.4.2.3
-rDNAttID: cn
-adminDisplayName: Samba4TopExtra
-adminDescription: Attributes used in top in Samba4 that OpenLDAP does not
-objectClassCategory: 2
-lDAPDisplayName: samba4TopExtra
-schemaIDGUID: 073598d0-635b-4685-a929-da731b98d84e
-systemOnly: TRUE
-mayContain: privilege
-systemPossSuperiors: lostAndFound
-defaultSecurityDescriptor: D:(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)(A;;RPLCLORC;;;AU)
-systemFlags: 16
-defaultHidingValue: TRUE
-objectCategory: CN=Class-Schema,${SCHEMADN}
-defaultObjectCategory: CN=Samba4TopExtra,${SCHEMADN}
-

diff --git a/source4/smb_server/smb/nttrans.c b/source4/smb_server/smb/nttrans.c
index e739f391b9d53321f7870c35e75b258eb8440981..91b6aba0963bb002aa2cda183af20935fe6faf8a 100644 (file)
--- a/source4/smb_server/smb/nttrans.c
+++ b/source4/smb_server/smb/nttrans.c
@@ -119,7 +119,7 @@ static NTSTATUS nttrans_create(struct smbsrv_request *req,
        params = trans->in.params.data;
 
        io->ntcreatex.in.flags            = IVAL(params,  0);
-       io->ntcreatex.in.root_fid         = IVAL(params,  4);
+       io->ntcreatex.in.root_fid.ntvfs   = smbsrv_pull_fnum(req, params, 4);
        io->ntcreatex.in.access_mask      = IVAL(params,  8);
        io->ntcreatex.in.alloc_size       = BVAL(params, 12);
        io->ntcreatex.in.file_attr        = IVAL(params, 20);

diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c
index 104caca4460acf162878825c754cd740267169c9..2c99a38575c04eafbc8d932acbf4b031eea7653d 100644 (file)
--- a/source4/smb_server/smb/reply.c
+++ b/source4/smb_server/smb/reply.c
@@ -2216,7 +2216,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req)
        /* notice that the word parameters are not word aligned, so we don't use VWV() */
        fname_len =                         SVAL(req->in.vwv, 5);
        io->ntcreatex.in.flags =            IVAL(req->in.vwv, 7);
-       io->ntcreatex.in.root_fid =         IVAL(req->in.vwv, 11);
+       io->ntcreatex.in.root_fid.ntvfs =   smbsrv_pull_fnum(req, req->in.vwv, 11);
        io->ntcreatex.in.access_mask =      IVAL(req->in.vwv, 15);
        io->ntcreatex.in.alloc_size =       BVAL(req->in.vwv, 19);
        io->ntcreatex.in.file_attr =        IVAL(req->in.vwv, 27);

diff --git a/source4/torture/basic/base.c b/source4/torture/basic/base.c
index 549db63b34fa24989b6dcfb949426f24c49f8d11..355c569bb388c2981b6e8e9e0c57dc4b45a1885c 100644 (file)
--- a/source4/torture/basic/base.c
+++ b/source4/torture/basic/base.c
@@ -1493,7 +1493,7 @@ static bool torture_samba3_errorpaths(struct torture_context *tctx)
 
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 1024*1024;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
@@ -1627,7 +1627,7 @@ static bool torture_samba3_errorpaths(struct torture_context *tctx)
                smbcli_close(cli_nt->tree, fnum);
 
                io.generic.level = RAW_OPEN_NTCREATEX;
-               io.ntcreatex.in.root_fid = 0;
+               io.ntcreatex.in.root_fid.fnum = 0;
                io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
                io.ntcreatex.in.alloc_size = 0;
                io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
@@ -1767,6 +1767,10 @@ NTSTATUS torture_base_init(void)
        torture_suite_add_suite(suite, torture_trans2_aliases(suite));
        torture_suite_add_1smb_test(suite, "TRANS2-SCAN", torture_trans2_scan);
        torture_suite_add_1smb_test(suite, "NTTRANS", torture_nttrans_scan);
+       torture_suite_add_1smb_test(suite, "CREATEX_ACCESS", torture_createx_access);
+       torture_suite_add_2smb_test(suite, "CREATEX_SHAREMODES_FILE", torture_createx_sharemodes_file);
+       torture_suite_add_2smb_test(suite, "CREATEX_SHAREMODES_DIR", torture_createx_sharemodes_dir);
+       torture_suite_add_1smb_test(suite, "MAXIMUM_ALLOWED", torture_maximum_allowed);
 
        torture_suite_add_simple_test(suite, "BENCH-HOLDCON", torture_holdcon);
        torture_suite_add_simple_test(suite, "BENCH-READWRITE", run_benchrw);

diff --git a/source4/torture/basic/charset.c b/source4/torture/basic/charset.c
index 5ac299dbbe1ca0da4132c10551578c7866871d91..2f50376f87da3751a920c14c0806127a3cb82d67 100644 (file)
--- a/source4/torture/basic/charset.c
+++ b/source4/torture/basic/charset.c
@@ -70,7 +70,7 @@ static NTSTATUS unicode_open(struct torture_context *tctx,
 
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;

diff --git a/source4/torture/basic/cxd_known.h b/source4/torture/basic/cxd_known.h
new file mode 100644 (file)
index 0000000..2fc0928
--- /dev/null
+++ b/source4/torture/basic/cxd_known.h
@@ -0,0 +1,8670 @@
+/**
+ * Results file used for BASE-CREATEX_* TESTS.
+ */
+
+enum {
+       CXD_CREATEX = 0,
+       CXD_FILE_READ = 1,
+       CXD_DIR_ENUMERATE = 1,
+       CXD_FILE_WRITE = 2,
+       CXD_DIR_CREATE_CHILD = 2,
+       CXD_FILE_EXECUTE = 3,
+       CXD_DIR_TRAVERSE = 3,
+       CXD_MAX,
+} cxd_results;
+
+enum cxd_test {
+       CXD_TEST_CREATEX_ACCESS            = 0,
+       CXD_TEST_CREATEX_ACCESS_EXHAUSTIVE = 1,
+       CXD_TEST_CREATEX_SHAREMODE         = 2,
+       CXD_TEST_CREATEX_SHAREMODE_EXTENDED = 3,
+};
+
+enum cxd_flags {
+       CXD_FLAGS_DIRECTORY             = 0x1,
+       CXD_FLAGS_MAKE_BEFORE_CREATEX   = 0x2,
+
+       CXD_FLAGS_MASK                  = 0x3,
+       CXD_FLAGS_COUNT                 = CXD_FLAGS_MASK + 1,
+};
+
+/**
+ * CXD.
+ */
+struct createx_data {
+       /* In. */
+       enum cxd_test   cxd_test;
+       enum cxd_flags  cxd_flags;
+       uint32_t        cxd_access1;
+       uint32_t        cxd_sharemode1;
+       uint32_t        cxd_access2;
+       uint32_t        cxd_sharemode2;
+
+       /* Out. */
+       NTSTATUS        cxd_result[CXD_MAX];
+       NTSTATUS        cxd_result2[CXD_MAX];
+};
+
+/**
+ * Known CXD results, for CREATEX_ACCESS and CREATEX_SHAREMODE.
+ * Taken by running against a Windows XP Pro 2002 Edition, Service Pack 2.
+ */
+static const struct createx_data cxd_known[] = {
+/**
+ * CXD_TEST_CREATEX_ACCESS data.
+ */
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =        0x1, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =        0x2, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =        0x4, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =        0x8, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =       0x10, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =       0x20, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =       0x40, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =       0x80, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =      0x100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =      0x200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =      0x400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =      0x800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =     0x1000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =     0x2000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =     0x4000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =     0x8000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =    0x10000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =    0x20000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =    0x40000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =    0x80000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =   0x800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x1000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x4000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x6000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x7000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0x8000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0xa000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 =  0xb000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x10000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x12000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x13000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x20000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x22000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x23000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x40000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x42000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x43000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x80000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x82000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags =   0, .cxd_access1 = 0x83000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =        0x1, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =        0x2, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =        0x4, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =        0x8, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =       0x10, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =       0x20, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =       0x40, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =       0x80, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =      0x100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =      0x200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =      0x400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =      0x800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =     0x1000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =     0x2000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =     0x4000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =     0x8000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =    0x10000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =    0x20000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =    0x40000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =    0x80000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =   0x800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x1000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x4000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x6000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x7000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0x8000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0xa000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 =  0xb000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x10000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x12000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x13000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x20000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x22000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x23000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x40000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x42000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x43000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x80000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x82000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x1, .cxd_access1 = 0x83000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =        0x1, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =        0x2, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =        0x4, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =        0x8, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =       0x10, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =       0x20, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =       0x40, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =       0x80, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =      0x100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =      0x200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =      0x400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =      0x800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =     0x1000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =     0x2000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =     0x4000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =     0x8000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =    0x10000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =    0x20000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =    0x40000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =    0x80000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =   0x800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x1000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x4000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x6000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x7000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0x8000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0xa000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 =  0xb000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x10000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x12000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x13000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x20000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x22000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x23000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x40000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x42000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x43000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x80000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x82000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x2, .cxd_access1 = 0x83000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =        0x1, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000001, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =        0x2, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000002, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =        0x4, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000004, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =        0x8, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000008, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =       0x10, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000010, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =       0x20, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000020, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =       0x40, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000040, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =       0x80, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000080, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =      0x100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000100, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =      0x200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000200, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =      0x400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000400, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =      0x800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000800, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =     0x1000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3001000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =     0x2000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3002000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =     0x4000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3004000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =     0x8000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3008000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =    0x10000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3010000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =    0x20000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3020000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =    0x40000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3040000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =    0x80000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3080000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3100000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3200000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3400000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =   0x800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3800000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x1000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x2000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x3000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x4000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x6000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x7000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0x8000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0xa000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 =  0xb000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x10000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x12000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x13000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x20000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x22000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x23000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x40000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x42000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x43000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x80000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x82000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 0, .cxd_flags = 0x3, .cxd_access1 = 0x83000000, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+/**
+ * CXD_TEST_CREATEX_SHAREMODE (file, non extended)
+ */
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_ACCESS_DENIED, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags =   0, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+/**
+ * CXD_TEST_CREATEX_SHAREMODE (dir, non extended)
+ */
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=0, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=1, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=2, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=3, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=4, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=5, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=6, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=0, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=1, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=2, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=3, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=4, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=5, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=6, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =          0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120089, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x120116, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x12019f, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a0, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1200a9, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201b6, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=         0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120089, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x120116, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x12019f, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a0, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1200a9, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201b6, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+  { .cxd_test = 2, .cxd_flags = 0x1, .cxd_access1 =   0x1201bf, .cxd_sharemode1=7, .cxd_access2=  0x1201bf, .cxd_sharemode2=7, .cxd_result = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }, .cxd_result2 = { NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, NT_STATUS_OK, }},
+};

diff --git a/source4/torture/basic/denytest.c b/source4/torture/basic/denytest.c
index bc64d4b2ffce7235430866ccb3ddb635612d796b..d13ea2c745ceb0064ce196ac231d412534656e74 100644 (file)
--- a/source4/torture/basic/denytest.c
+++ b/source4/torture/basic/denytest.c
@@ -22,7 +22,11 @@
 #include "system/filesys.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/libcli.h"
+#include "libcli/security/security.h"
 #include "torture/util.h"
+#include "torture/smbtorture.h"
+#include "libcli/util/clilsa.h"
+#include "cxd_known.h"
 
 extern int torture_failures;
 
@@ -1765,7 +1769,7 @@ static bool torture_ntdenytest(struct torture_context *tctx,
        GetTimeOfDay(&tv_start);
 
        io1.ntcreatex.level = RAW_OPEN_NTCREATEX;
-       io1.ntcreatex.in.root_fid = 0;
+       io1.ntcreatex.in.root_fid.fnum = 0;
        io1.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
        io1.ntcreatex.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
        io1.ntcreatex.in.file_attr = 0;
@@ -1911,10 +1915,19 @@ bool torture_ntdenytest2(struct torture_context *torture,
        return torture_ntdenytest(torture, cli1, cli2, 0);
 }
 
+#define COMPARE_STATUS(status, correct) do { \
+       if (!NT_STATUS_EQUAL(status, correct)) { \
+               torture_result(tctx, TORTURE_FAIL, \
+                       "(%s) Incorrect status %s - should be %s\n", \
+                       __location__, nt_errstr(status), nt_errstr(correct)); \
+               ret = false; \
+               failed = true; \
+       }} while (0)
 
 #define CHECK_STATUS(status, correct) do { \
        if (!NT_STATUS_EQUAL(status, correct)) { \
-               torture_comment(tctx, "(%s) Incorrect status %s - should be %s\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                       "(%s) Incorrect status %s - should be %s\n", \
                       __location__, nt_errstr(status), nt_errstr(correct)); \
                ret = false; \
                goto done; \
@@ -1922,7 +1935,8 @@ bool torture_ntdenytest2(struct torture_context *torture,
 
 #define CHECK_VAL(v, correct) do { \
        if ((v) != (correct)) { \
-               torture_comment(tctx, "(%s) wrong value for %s  0x%x - should be 0x%x\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                     "(%s) wrong value for %s  0x%x - should be 0x%x\n", \
                       __location__, #v, (int)(v), (int)correct); \
                ret = false; \
        }} while (0)
@@ -2030,4 +2044,739 @@ done:
        return ret;
 }
 
+#define CXD_MATCHES(_cxd, i)                                            \
+       ((cxd_known[i].cxd_test == (_cxd)->cxd_test) &&                 \
+        (cxd_known[i].cxd_flags == (_cxd)->cxd_flags) &&               \
+        (cxd_known[i].cxd_access1 == (_cxd)->cxd_access1) &&           \
+        (cxd_known[i].cxd_sharemode1 == (_cxd)->cxd_sharemode1) &&     \
+        (cxd_known[i].cxd_access2 == (_cxd)->cxd_access2) &&           \
+        (cxd_known[i].cxd_sharemode2 == (_cxd)->cxd_sharemode2))
+
+static int cxd_find_known(struct createx_data *cxd)
+{
+       static int i = -1;
+
+       /* Optimization for tests which we don't have results saved for. */
+       if ((cxd->cxd_test == CXD_TEST_CREATEX_ACCESS_EXHAUSTIVE) ||
+           (cxd->cxd_test == CXD_TEST_CREATEX_SHAREMODE_EXTENDED))
+               return -1;
+
+       /* Optimization: If our cxd_known table is too large, it hurts test
+        * performance to search through the entire table each time. If the
+        * caller can pass in the previous result, we can try the next entry.
+        * This works if results are taken directly from the same code. */
+       i++;
+       if ((i >= 0) && (i < sizeof(cxd_known) / sizeof(cxd_known[0])) &&
+           CXD_MATCHES(cxd, i))
+               return i;
+
+       for (i = 0; i < (sizeof(cxd_known) / sizeof(cxd_known[0])); i++) {
+               if (CXD_MATCHES(cxd, i))
+                       return i;
+       }
+
+       return -1;
+}
+
+#define FILL_NTCREATEX(_struct, _init...)                       \
+       do {                                                    \
+               (_struct)->generic.level = RAW_OPEN_NTCREATEX;  \
+               (_struct)->ntcreatex.in                         \
+                   = (typeof((_struct)->ntcreatex.in)) {_init};\
+       } while (0)
+
+#define CREATEX_NAME "\\createx_dir"
+
+static bool createx_make_dir(struct torture_context *tctx,
+    struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, const char *fname)
+{
+       bool ret = true;
+       NTSTATUS status;
+
+       status = smbcli_mkdir(tree, fname);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+ done:
+       return ret;
+}
+
+static bool createx_make_file(struct torture_context *tctx,
+    struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, const char *fname)
+{
+       union smb_open open_parms;
+       bool ret = true;
+       NTSTATUS status;
+
+       FILL_NTCREATEX(&open_parms,
+           .flags = 0,
+           .access_mask = SEC_RIGHTS_FILE_ALL,
+           .file_attr = FILE_ATTRIBUTE_NORMAL,
+           .share_access = 0,
+           .open_disposition = NTCREATEX_DISP_CREATE,
+           .create_options = 0,
+           .fname = fname,
+       );
+       status = smb_raw_open(tree, mem_ctx, &open_parms);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       status = smbcli_close(tree, open_parms.ntcreatex.out.file.fnum);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+ done:
+       return ret;
+}
+
+static void createx_fill_dir(union smb_open *open_parms, int accessmode,
+    int sharemode, const char *fname)
+{
+       FILL_NTCREATEX(open_parms,
+           .flags = 0,
+           .access_mask = accessmode,
+           .file_attr = FILE_ATTRIBUTE_DIRECTORY,
+           .share_access = sharemode,
+           .open_disposition = NTCREATEX_DISP_OPEN_IF,
+           .create_options = NTCREATEX_OPTIONS_DIRECTORY,
+           .fname = fname,
+       );
+}
+
+static void createx_fill_file(union smb_open *open_parms, int accessmode,
+    int sharemode, const char *fname)
+{
+       FILL_NTCREATEX(open_parms,
+           .flags = 0,
+           .access_mask = accessmode,
+           .file_attr = FILE_ATTRIBUTE_NORMAL,
+           .share_access = sharemode,
+           .open_disposition = NTCREATEX_DISP_OPEN_IF,
+           .create_options = 0,
+           .fname = fname,
+            .root_fid = { .fnum = 0 },
+       );
+}
+
+static int data_file_fd = -1;
+
+#define KNOWN   "known"
+#define CHILD   "child"
+static bool createx_test_dir(struct torture_context *tctx,
+    struct smbcli_tree *tree, int fnum, TALLOC_CTX *mem_ctx, NTSTATUS *result)
+{
+       bool ret = true;
+       NTSTATUS status;
+       union smb_open open_parms;
+
+       /* bypass original handle to guarantee creation */
+       FILL_NTCREATEX(&open_parms,
+           .flags = 0,
+           .access_mask = SEC_RIGHTS_FILE_ALL,
+           .file_attr = FILE_ATTRIBUTE_NORMAL,
+           .share_access = 0,
+           .open_disposition = NTCREATEX_DISP_CREATE,
+           .create_options = 0,
+           .fname = CREATEX_NAME "\\" KNOWN,
+       );
+       status = smb_raw_open(tree, mem_ctx, &open_parms);
+       CHECK_STATUS(status, NT_STATUS_OK);
+       smbcli_close(tree, open_parms.ntcreatex.out.file.fnum);
+
+       result[CXD_DIR_ENUMERATE] = NT_STATUS_OK;
+
+       /* try to create a child */
+       FILL_NTCREATEX(&open_parms,
+           .flags = 0,
+           .access_mask = SEC_RIGHTS_FILE_ALL,
+           .file_attr = FILE_ATTRIBUTE_NORMAL,
+           .share_access = 0,
+           .open_disposition = NTCREATEX_DISP_CREATE,
+           .create_options = 0,
+           .fname = CHILD,
+           .root_fid = { .fnum = fnum },
+       );
+
+       result[CXD_DIR_CREATE_CHILD] =
+           smb_raw_open(tree, mem_ctx, &open_parms);
+       smbcli_close(tree, open_parms.ntcreatex.out.file.fnum);
+
+       /* try to traverse dir to known good file */
+       FILL_NTCREATEX(&open_parms,
+           .flags = 0,
+           .access_mask = SEC_RIGHTS_FILE_ALL,
+           .file_attr = FILE_ATTRIBUTE_NORMAL,
+           .share_access = 0,
+           .open_disposition = NTCREATEX_DISP_OPEN,
+           .create_options = 0,
+           .fname = KNOWN,
+           .root_fid = {.fnum = fnum},
+       );
+
+       result[CXD_DIR_TRAVERSE] =
+           smb_raw_open(tree, mem_ctx, &open_parms);
+
+
+       smbcli_close(tree, open_parms.ntcreatex.out.file.fnum);
+       smbcli_unlink(tree, CREATEX_NAME "\\" KNOWN);
+       smbcli_unlink(tree, CREATEX_NAME "\\" CHILD);
+
+ done:
+       return ret;
+}
+
+static bool createx_test_file(struct torture_context *tctx,
+    struct smbcli_tree *tree, int fnum, TALLOC_CTX *mem_ctx, NTSTATUS *result)
+{
+       union smb_read rd = {};
+       union smb_write wr = {};
+       char buf[256] = "";
+
+       rd.readx.level = RAW_READ_READX;
+       rd.readx.in.file.fnum = fnum;
+       rd.readx.in.mincnt = sizeof(buf);
+       rd.readx.in.maxcnt = sizeof(buf);
+       rd.readx.out.data = (uint8_t *)buf;
+
+       result[CXD_FILE_READ] = smb_raw_read(tree, &rd);
+
+       wr.writex.level = RAW_WRITE_WRITEX;
+       wr.writex.in.file.fnum = fnum;
+       wr.writex.in.count = sizeof(buf);
+       wr.writex.in.data = (uint8_t *)buf;
+
+       result[CXD_FILE_WRITE] = smb_raw_write(tree, &wr);
+
+       memset(&rd, 0, sizeof(rd));
+       rd.readx.level = RAW_READ_READX;
+       rd.readx.in.file.fnum = fnum;
+       rd.readx.in.mincnt = sizeof(buf);
+       rd.readx.in.maxcnt = sizeof(buf);
+       rd.readx.in.read_for_execute = 1;
+       rd.readx.out.data = (uint8_t *)buf;
+
+       result[CXD_FILE_EXECUTE] = smb_raw_read(tree, &rd);
+
+       return true;
+}
+
+/* TODO When redirecting stdout to a file, the progress bar really screws up
+ * the output. Could use a switch "--noprogress", or direct the progress bar to
+ * stderr? No other solution? */
+static void createx_progress_bar(struct torture_context *tctx, uint_t i,
+    uint_t total, uint_t skipped)
+{
+       if (torture_setting_bool(tctx, "progress", true)) {
+               torture_comment(tctx, "%5d/%5d (%d skipped)\r", i, total,
+                   skipped);
+               fflush(stdout);
+       }
+}
+
+static bool torture_createx_specific(struct torture_context *tctx, struct
+    smbcli_state *cli, struct smbcli_state *cli2, TALLOC_CTX *mem_ctx, struct
+    createx_data *cxd, int estimated_count)
+{
+       static int call_count = 1;
+       static int unskipped_call_count = 1;
+       const char *fname = CREATEX_NAME;
+       int fnum = -1, fnum2 = -1, res, i;
+       union smb_open open_parms1, open_parms2;
+       bool ret = true;
+       bool is_dir = cxd->cxd_flags & CXD_FLAGS_DIRECTORY;
+       NTSTATUS *result = &cxd->cxd_result[0];
+       NTSTATUS *result2 = &cxd->cxd_result2[0];
+       bool found = false, failed = false;
+
+       bool (*make_func)(struct torture_context *,
+           struct smbcli_tree *, TALLOC_CTX *, const char *);
+       void (*fill_func)(union smb_open *, int, int, const char *);
+       bool (*test_func)(struct torture_context *,
+           struct smbcli_tree *, int, TALLOC_CTX *, NTSTATUS *);
+       NTSTATUS (*destroy_func)(struct smbcli_tree *, const char *);
+
+       if (is_dir) {
+               make_func = createx_make_dir;
+               fill_func = createx_fill_dir;
+               test_func = createx_test_dir;
+               destroy_func = smbcli_rmdir;
+       } else {
+               make_func = createx_make_file;
+               fill_func = createx_fill_file;
+               test_func = createx_test_file;
+               destroy_func = smbcli_unlink;
+       }
+
+       /* Skip all SACL related tests. */
+       if ((!torture_setting_bool(tctx, "sacl_support", true)) &&
+           ((cxd->cxd_access1 & SEC_FLAG_SYSTEM_SECURITY) ||
+            (cxd->cxd_access2 & SEC_FLAG_SYSTEM_SECURITY)))
+               goto done;
+
+       if (cxd->cxd_flags & CXD_FLAGS_MAKE_BEFORE_CREATEX) {
+               ret = make_func(tctx, cli->tree, mem_ctx, fname);
+               if (!ret) {
+                       torture_result(tctx, TORTURE_FAIL,
+                               "Initial creation failed\n");
+                       goto done;
+               }
+       }
+
+       /* Initialize. */
+       fill_func(&open_parms1, cxd->cxd_access1, cxd->cxd_sharemode1, fname);
+
+       if (cxd->cxd_test == CXD_TEST_CREATEX_SHAREMODE) {
+               fill_func(&open_parms2, cxd->cxd_access2, cxd->cxd_sharemode2,
+                   fname);
+       }
+
+       for (i = CXD_CREATEX + 1; i < CXD_MAX; i++) {
+               result[i] = NT_STATUS_UNSUCCESSFUL;
+               result2[i] = NT_STATUS_UNSUCCESSFUL;
+       }
+
+       /* Perform open(s). */
+       result[CXD_CREATEX] = smb_raw_open(cli->tree, mem_ctx, &open_parms1);
+       if (NT_STATUS_IS_OK(result[CXD_CREATEX])) {
+               fnum = open_parms1.ntcreatex.out.file.fnum;
+               ret = test_func(tctx, cli->tree, fnum, mem_ctx, result);
+               smbcli_close(cli->tree, fnum);
+       }
+
+       if (cxd->cxd_test == CXD_TEST_CREATEX_SHAREMODE) {
+               result2[CXD_CREATEX] = smb_raw_open(cli2->tree, mem_ctx,
+                   &open_parms2);
+               if (NT_STATUS_IS_OK(result2[CXD_CREATEX])) {
+                       fnum2 = open_parms2.ntcreatex.out.file.fnum;
+                       ret = test_func(tctx, cli2->tree, fnum2, mem_ctx,
+                           result2);
+                       smbcli_close(cli2->tree, fnum2);
+               }
+       }
+
+       if (data_file_fd >= 0) {
+               found = true;
+               res = write(data_file_fd, &cxd, sizeof(cxd));
+               if (res != sizeof(cxd)) {
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s): write failed: %s!",
+                               __location__, strerror(errno));
+                       ret = false;
+               }
+       } else if ((res = cxd_find_known(cxd)) >= 0) {
+               found = true;
+               for (i = 0; i < CXD_MAX; i++) {
+                       /* Note: COMPARE_STATUS will set the "failed" bool. */
+                       COMPARE_STATUS(result[i], cxd_known[res].cxd_result[i]);
+                       if (i == 0 && !NT_STATUS_IS_OK(result[i]))
+                               break;
+
+                       if (cxd->cxd_test == CXD_TEST_CREATEX_SHAREMODE) {
+                               COMPARE_STATUS(result2[i],
+                                   cxd_known[res].cxd_result2[i]);
+                               if (i == 0 && !NT_STATUS_IS_OK(result2[i]))
+                                       break;
+                       }
+               }
+       }
+
+       /* We print if its not in the "cxd_known" list or if we fail. */
+       if (!found || failed) {
+               torture_comment(tctx,
+                   "  { .cxd_test = %d, .cxd_flags = %#3x, "
+                   ".cxd_access1 = %#10x, .cxd_sharemode1=%1x, "
+                   ".cxd_access2=%#10x, .cxd_sharemode2=%1x, "
+                   ".cxd_result = { ", cxd->cxd_test, cxd->cxd_flags,
+                   cxd->cxd_access1, cxd->cxd_sharemode1, cxd->cxd_access2,
+                   cxd->cxd_sharemode2);
+               for (i = 0; i < CXD_MAX; i++) {
+                       torture_comment(tctx, "%s, ", nt_errstr(result[i]));
+                       if (i == 0 && !NT_STATUS_IS_OK(result[i]))
+                               break;
+               }
+               torture_comment(tctx, "}");
+               if (cxd->cxd_test == CXD_TEST_CREATEX_SHAREMODE) {
+                       torture_comment(tctx, ", .cxd_result2 = { ");
+                       for (i = 0; i < CXD_MAX; i++) {
+                               torture_comment(tctx, "%s, ",
+                                               nt_errstr(result2[i]));
+                               if (i == 0 && !NT_STATUS_IS_OK(result2[i]))
+                                       break;
+                       }
+                       torture_comment(tctx, "}");
+               }
+               torture_comment(tctx, "}, \n");
+       } else {
+               createx_progress_bar(tctx, call_count, estimated_count,
+                   call_count - unskipped_call_count);
+       }
+       /* Count tests that we didn't skip. */
+       unskipped_call_count++;
+ done:
+       call_count++;
+
+       destroy_func(cli->tree, fname);
+       return ret;
+}
+
+uint32_t sec_access_bit_groups[] = {
+       SEC_RIGHTS_FILE_READ,
+       SEC_RIGHTS_FILE_WRITE,
+       SEC_RIGHTS_FILE_EXECUTE
+};
+#define NUM_ACCESS_GROUPS     (sizeof(sec_access_bit_groups) / sizeof(uint32_t))
+#define ACCESS_GROUPS_COUNT   ((1 << NUM_ACCESS_GROUPS))
+#define BITSINBYTE 8
+
+/* Note: See NTCREATEX_SHARE_ACCESS_{NONE,READ,WRITE,DELETE} for share mode
+ * declarations. */
+#define NUM_SHAREMODE_PERMUTATIONS 8
+
+/**
+ * NTCREATEX and SHARE MODE test.
+ *
+ * Open with combinations of (access_mode, share_mode).
+ *  - Check status
+ * Open 2nd time with combination of (access_mode2, share_mode2).
+ *  - Check status
+ * Perform operations to verify?
+ *  - Read
+ *  - Write
+ *  - Delete
+ */
+bool torture_createx_sharemodes(struct torture_context *tctx,
+                               struct smbcli_state *cli,
+                               struct smbcli_state *cli2,
+                               bool dir,
+                               bool extended)
+{
+       TALLOC_CTX *mem_ctx;
+       bool ret = true;
+       int i, j, est;
+       int gp1, gp2; /* group permuters */
+       struct createx_data cxd = {0};
+       int num_access_bits1 = sizeof(cxd.cxd_access1) * BITSINBYTE;
+       int num_access_bits2 = sizeof(cxd.cxd_access2) * BITSINBYTE;
+
+       mem_ctx = talloc_init("createx_sharemodes");
+       if (!mem_ctx)
+               return false;
+
+       if (!torture_setting_bool(tctx, "sacl_support", true))
+               torture_warning(tctx, "Skipping SACL related tests!\n");
+
+       cxd.cxd_test = extended ? CXD_TEST_CREATEX_SHAREMODE_EXTENDED :
+           CXD_TEST_CREATEX_SHAREMODE;
+       cxd.cxd_flags = dir ? CXD_FLAGS_DIRECTORY: 0;
+
+       /* HACK for progress bar: figure out estimated count. */
+       est = (NUM_SHAREMODE_PERMUTATIONS * NUM_SHAREMODE_PERMUTATIONS) *
+           ((ACCESS_GROUPS_COUNT * ACCESS_GROUPS_COUNT) +
+            (extended ? num_access_bits1 * num_access_bits2 : 0));
+
+       /* Blank slate. */
+       smbcli_deltree(cli->tree, CREATEX_NAME);
+       smbcli_unlink(cli->tree, CREATEX_NAME);
+
+       /* Choose 2 random share modes. */
+       for (cxd.cxd_sharemode1 = 0;
+            cxd.cxd_sharemode1 < NUM_SHAREMODE_PERMUTATIONS;
+            cxd.cxd_sharemode1++) {
+               for (cxd.cxd_sharemode2 = 0;
+                    cxd.cxd_sharemode2 < NUM_SHAREMODE_PERMUTATIONS;
+                    cxd.cxd_sharemode2++) {
+
+                       /* Permutate through our access_bit_groups. */
+                       for (gp1 = 0; gp1 < ACCESS_GROUPS_COUNT; gp1++) {
+                               for (gp2 = 0; gp2 < ACCESS_GROUPS_COUNT; gp2++)
+                               {
+                                       cxd.cxd_access1 = cxd.cxd_access2 = 0;
+
+                                       for (i = 0; i < NUM_ACCESS_GROUPS; i++)
+                                       {
+                                               cxd.cxd_access1 |=
+                                                   (gp1 & (1 << i)) ?
+                                                   sec_access_bit_groups[i]:0;
+                                               cxd.cxd_access2 |=
+                                                   (gp2 & (1 << i)) ?
+                                                   sec_access_bit_groups[i]:0;
+                                       }
+
+                                       torture_createx_specific(tctx, cli,
+                                          cli2, mem_ctx, &cxd, est);
+                               }
+                       }
+
+                       /* Only do the single access bits on an extended run. */
+                       if (!extended)
+                               continue;
+
+                       for (i = 0; i < num_access_bits1; i++) {
+                               for (j = 0; j < num_access_bits2; j++) {
+                                       cxd.cxd_access1 = 1ull << i;
+                                       cxd.cxd_access2 = 1ull << j;
+
+                                       torture_createx_specific(tctx, cli,
+                                           cli2, mem_ctx, &cxd, est);
+                               }
+                       }
+               }
+       }
+       torture_comment(tctx, "\n");
+
+       talloc_free(mem_ctx);
+       return ret;
+}
+
+bool torture_createx_sharemodes_file(struct torture_context *tctx,
+    struct smbcli_state *cli, struct smbcli_state *cli2)
+{
+       return torture_createx_sharemodes(tctx, cli, cli2, false, false);
+}
+
+bool torture_createx_sharemodes_dir(struct torture_context *tctx,
+    struct smbcli_state *cli, struct smbcli_state *cli2)
+{
+       return torture_createx_sharemodes(tctx, cli, cli2, true, false);
+}
+
+bool torture_createx_access(struct torture_context *tctx,
+    struct smbcli_state *cli)
+{
+       TALLOC_CTX *mem_ctx;
+       bool ret = true;
+       uint32_t group_permuter;
+       uint32_t i;
+       struct createx_data cxd = {0};
+       int est;
+       int num_access_bits = sizeof(cxd.cxd_access1) * BITSINBYTE;
+
+       mem_ctx = talloc_init("createx_dir");
+       if (!mem_ctx)
+               return false;
+
+       if (!torture_setting_bool(tctx, "sacl_support", true))
+               torture_warning(tctx, "Skipping SACL related tests!\n");
+
+       cxd.cxd_test = CXD_TEST_CREATEX_ACCESS;
+
+       /* HACK for progress bar: figure out estimated count. */
+       est = CXD_FLAGS_COUNT * (ACCESS_GROUPS_COUNT + (num_access_bits * 3));
+
+       /* Blank slate. */
+       smbcli_deltree(cli->tree, CREATEX_NAME);
+       smbcli_unlink(cli->tree, CREATEX_NAME);
+
+       for (cxd.cxd_flags = 0; cxd.cxd_flags <= CXD_FLAGS_MASK;
+            cxd.cxd_flags++) {
+               /**
+                * This implements a basic permutation of all elements of
+                * 'bit_group'.  group_permuter is a bit field representing
+                * which groups to turn on.
+               */
+               for (group_permuter = 0; group_permuter < (1 <<
+                       NUM_ACCESS_GROUPS); group_permuter++) {
+                       for (i = 0, cxd.cxd_access1 = 0;
+                            i < NUM_ACCESS_GROUPS; i++) {
+                               cxd.cxd_access1 |= (group_permuter & (1 << i))
+                                   ? sec_access_bit_groups[i] : 0;
+                       }
 
+                       torture_createx_specific(tctx, cli, NULL, mem_ctx,
+                           &cxd, est);
+               }
+               for (i = 0; i < num_access_bits; i++) {
+                       /* And now run through the single access bits. */
+                       cxd.cxd_access1 = 1 << i;
+                       torture_createx_specific(tctx, cli, NULL, mem_ctx,
+                           &cxd, est);
+
+                       /* Does SEC_FLAG_MAXIMUM_ALLOWED override? */
+                       cxd.cxd_access1 |= SEC_FLAG_MAXIMUM_ALLOWED;
+                       torture_createx_specific(tctx, cli, NULL, mem_ctx,
+                           &cxd, est);
+
+                       /* What about SEC_FLAG_SYSTEM_SECURITY? */
+                       cxd.cxd_access1 |= SEC_FLAG_SYSTEM_SECURITY;
+                       torture_createx_specific(tctx, cli, NULL, mem_ctx,
+                           &cxd, est);
+               }
+       }
+
+       talloc_free(mem_ctx);
+       return ret;
+}
+
+#define ACCESS_KNOWN_MASK 0xF31F01FFull
+
+bool torture_createx_access_exhaustive(struct torture_context *tctx,
+    struct smbcli_state *cli)
+{
+       char *data_file;
+       TALLOC_CTX *mem_ctx;
+       bool ret = true, first;
+       uint32_t i;
+       struct createx_data cxd = {0};
+
+       mem_ctx = talloc_init("createx_dir");
+       if (!mem_ctx)
+               return false;
+
+       if (!torture_setting_bool(tctx, "sacl_support", true))
+               torture_warning(tctx, "Skipping SACL related tests!\n");
+
+       data_file = getenv("CREATEX_DATA");
+       if (data_file) {
+               data_file_fd = open(data_file, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+               if (data_file_fd < 0) {
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s): data file open failedu: %s!",
+                               __location__, strerror(errno));
+                       ret = false;
+                       goto done;
+               }
+       }
+
+       /* Blank slate. */
+       smbcli_deltree(cli->tree, CREATEX_NAME);
+       smbcli_unlink(cli->tree, CREATEX_NAME);
+
+       cxd.cxd_test = CXD_TEST_CREATEX_ACCESS_EXHAUSTIVE;
+
+       for (cxd.cxd_flags = 0; cxd.cxd_flags <= CXD_FLAGS_MASK;
+            cxd.cxd_flags++) {
+               for (i = 0, first = true; (i != 0) || first; first = false,
+                    i = ((i | ~ACCESS_KNOWN_MASK) + 1) & ACCESS_KNOWN_MASK) {
+                       cxd.cxd_access1 = i;
+                       ret = torture_createx_specific(tctx, cli, NULL,
+                           mem_ctx, &cxd, 0);
+                       if (!ret)
+                               break;
+               }
+       }
+
+       close(data_file_fd);
+       data_file_fd = -1;
+
+ done:
+       talloc_free(mem_ctx);
+       return ret;
+}
+
+#define MAXIMUM_ALLOWED_FILE    "torture_maximum_allowed"
+bool torture_maximum_allowed(struct torture_context *tctx,
+    struct smbcli_state *cli)
+{
+       struct security_descriptor *sd, *sd_orig;
+       union smb_open io = {};
+       static TALLOC_CTX *mem_ctx;
+       int fnum, i;
+       bool ret = true;
+       NTSTATUS status;
+       union smb_fileinfo q;
+       const char *owner_sid;
+       bool has_restore_privilege, has_backup_privilege;
+
+       mem_ctx = talloc_init("torture_maximum_allowed");
+
+       if (!torture_setting_bool(tctx, "sacl_support", true))
+               torture_warning(tctx, "Skipping SACL related tests!\n");
+
+       sd = security_descriptor_dacl_create(mem_ctx,
+           0, NULL, NULL,
+           SID_NT_AUTHENTICATED_USERS,
+           SEC_ACE_TYPE_ACCESS_ALLOWED,
+           SEC_RIGHTS_FILE_READ,
+           0, NULL);
+
+       /* Blank slate */
+       smbcli_unlink(cli->tree, MAXIMUM_ALLOWED_FILE);
+
+       /* create initial file with restrictive SD */
+       io.generic.level = RAW_OPEN_NTTRANS_CREATE;
+       io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
+       io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
+       io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
+       io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
+       io.ntcreatex.in.fname = MAXIMUM_ALLOWED_FILE;
+       io.ntcreatex.in.sec_desc = sd;
+
+       status = smb_raw_open(cli->tree, mem_ctx, &io);
+       CHECK_STATUS(status, NT_STATUS_OK);
+       fnum = io.ntcreatex.out.file.fnum;
+
+       /* the correct answers for this test depends on whether the
+          user has restore privileges. To find that out we first need
+          to know our SID - get it from the owner_sid of the file we
+          just created */
+       q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
+       q.query_secdesc.in.file.fnum = fnum;
+       q.query_secdesc.in.secinfo_flags = SECINFO_DACL | SECINFO_OWNER;
+       status = smb_raw_fileinfo(cli->tree, tctx, &q);
+       CHECK_STATUS(status, NT_STATUS_OK);
+       sd_orig = q.query_secdesc.out.sd;
+
+       owner_sid = dom_sid_string(tctx, sd_orig->owner_sid);
+
+       status = torture_check_privilege(cli, 
+                                        owner_sid, 
+                                        sec_privilege_name(SEC_PRIV_RESTORE));
+       has_restore_privilege = NT_STATUS_IS_OK(status);
+       torture_comment(tctx, "Checked SEC_PRIV_RESTORE for %s - %s\n", 
+                       owner_sid,
+                       has_restore_privilege?"Yes":"No");
+
+       status = torture_check_privilege(cli, 
+                                        owner_sid, 
+                                        sec_privilege_name(SEC_PRIV_BACKUP));
+       has_backup_privilege = NT_STATUS_IS_OK(status);
+       torture_comment(tctx, "Checked SEC_PRIV_BACKUP for %s - %s\n", 
+                       owner_sid,
+                       has_backup_privilege?"Yes":"No");
+
+       smbcli_close(cli->tree, fnum);
+
+       for (i = 0; i < 32; i++) {
+               uint32_t mask = SEC_FLAG_MAXIMUM_ALLOWED | (1u << i);
+               uint32_t ok_mask = SEC_RIGHTS_FILE_READ | SEC_GENERIC_READ | 
+                       SEC_STD_DELETE | SEC_STD_WRITE_DAC;
+
+               if (has_restore_privilege) {
+                       ok_mask |= SEC_RIGHTS_PRIV_RESTORE;
+               }
+               if (has_backup_privilege) {
+                       ok_mask |= SEC_RIGHTS_PRIV_BACKUP;
+               }
+
+               /* Skip all SACL related tests. */
+               if ((!torture_setting_bool(tctx, "sacl_support", true)) &&
+                   (mask & SEC_FLAG_SYSTEM_SECURITY))
+                       continue;
+
+               memset(&io, 0, sizeof(io));
+               io.generic.level = RAW_OPEN_NTTRANS_CREATE;
+               io.ntcreatex.in.access_mask = mask;
+               io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
+               io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
+               io.ntcreatex.in.impersonation =
+                   NTCREATEX_IMPERSONATION_ANONYMOUS;
+               io.ntcreatex.in.fname = MAXIMUM_ALLOWED_FILE;
+
+               status = smb_raw_open(cli->tree, mem_ctx, &io);
+               if (mask & ok_mask ||
+                   mask == SEC_FLAG_MAXIMUM_ALLOWED) {
+                       CHECK_STATUS(status, NT_STATUS_OK);
+               } else {
+                       if (mask & SEC_FLAG_SYSTEM_SECURITY) {
+                               CHECK_STATUS(status, NT_STATUS_PRIVILEGE_NOT_HELD);
+                       } else {
+                               CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
+                       }
+               }
+
+               fnum = io.ntcreatex.out.file.fnum;
+
+               smbcli_close(cli->tree, fnum);
+       }
+
+ done:
+       smbcli_unlink(cli->tree, MAXIMUM_ALLOWED_FILE);
+       return ret;
+}

diff --git a/source4/torture/basic/disconnect.c b/source4/torture/basic/disconnect.c
index 89e05d6839fa762f68be8f778cfb76b6e1ad1e4a..0de0910512dbf195f709e495a469ce2c92f04659 100644 (file)
--- a/source4/torture/basic/disconnect.c
+++ b/source4/torture/basic/disconnect.c
@@ -49,7 +49,7 @@ static bool test_disconnect_open(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        printf("trying open/disconnect\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA;
        io.ntcreatex.in.create_options = 0;

diff --git a/source4/torture/basic/unlink.c b/source4/torture/basic/unlink.c
index 9e13021d2056a374c7a4145d32e7269552ea3cd5..5d0e4f696405bad24c7673e372242a6860f5585f 100644 (file)
--- a/source4/torture/basic/unlink.c
+++ b/source4/torture/basic/unlink.c
@@ -65,7 +65,7 @@ bool torture_unlinktest(struct torture_context *tctx, struct smbcli_state *cli)
        torture_comment(tctx, "testing unlink after ntcreatex with DELETE access\n");
 
        io.ntcreatex.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
        io.ntcreatex.in.file_attr = 0;

diff --git a/source4/torture/config.mk b/source4/torture/config.mk
index b85a0f84b1ce7291473b574402ad10ed4b557cca..00362b6358357cdc9f341935ee0798a21f9eb5d9 100644 (file)
--- a/source4/torture/config.mk
+++ b/source4/torture/config.mk
@@ -125,6 +125,10 @@ torture_rpc_OBJ_FILES = $(addprefix $(torturesrcdir)/rpc/, \
 
 $(eval $(call proto_header_template,$(torturesrcdir)/rpc/proto.h,$(torture_rpc_OBJ_FILES:.o=.c)))
 
+#################################
+# RPC/Local DRSUAPI tests
+mkinclude drs/config.mk
+
 #################################
 # Start SUBSYSTEM TORTURE_RAP
 [MODULE::TORTURE_RAP]

diff --git a/source4/torture/drs/config.mk b/source4/torture/drs/config.mk
new file mode 100644 (file)
index 0000000..14f673e
--- /dev/null
+++ b/source4/torture/drs/config.mk
@@ -0,0 +1,24 @@
+#################################
+# Start SUBSYSTEM TORTURE_DRS
+[MODULE::TORTURE_DRS]
+SUBSYSTEM = smbtorture
+OUTPUT_TYPE = MERGED_OBJ
+INIT_FUNCTION = torture_drs_init
+PRIVATE_DEPENDENCIES = \
+               NDR_TABLE RPC_NDR_UNIXINFO dcerpc_samr RPC_NDR_WINREG RPC_NDR_INITSHUTDOWN \
+               RPC_NDR_OXIDRESOLVER RPC_NDR_EVENTLOG RPC_NDR_ECHO RPC_NDR_SVCCTL \
+               RPC_NDR_NETLOGON dcerpc_atsvc dcerpc_mgmt RPC_NDR_DRSUAPI \
+               RPC_NDR_LSA RPC_NDR_EPMAPPER RPC_NDR_DFS RPC_NDR_FRSAPI RPC_NDR_SPOOLSS \
+               RPC_NDR_SRVSVC RPC_NDR_WKSSVC RPC_NDR_ROT RPC_NDR_DSSETUP \
+               RPC_NDR_REMACT RPC_NDR_OXIDRESOLVER RPC_NDR_NTSVCS WB_HELPER LIBSAMBA-NET \
+               LIBCLI_AUTH POPT_CREDENTIALS TORTURE_LDAP TORTURE_UTIL TORTURE_RAP \
+               dcerpc_server service process_model ntvfs SERVICE_SMB RPC_NDR_BROWSER LIBCLI_DRSUAPI TORTURE_LDB_MODULE
+# End SUBSYSTEM TORTURE_DRS
+#################################
+
+TORTURE_DRS_OBJ_FILES = \
+               $(torturesrcdir)/drs/drs_init.o \
+               $(torturesrcdir)/drs/drs_util.o \
+               $(torturesrcdir)/drs/internal/prefixmap_tests.o
+
+$(eval $(call proto_header_template,$(torturesrcdir)/drs/proto.h,$(TORTURE_DRS_OBJ_FILES:.o=.c)))

diff --git a/source4/torture/drs/drs_init.c b/source4/torture/drs/drs_init.c
new file mode 100644 (file)
index 0000000..081565f
--- /dev/null
+++ b/source4/torture/drs/drs_init.c
@@ -0,0 +1,71 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DRSUAPI utility functions to be used in torture tests
+
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "torture/smbtorture.h"
+#include "torture/rpc/drsuapi.h"
+#include "torture/drs/proto.h"
+
+/**
+ * DRSUAPI tests to be executed remotely
+ */
+static struct torture_suite * torture_drs_rpc_suite(TALLOC_CTX *mem_ctx)
+{
+       struct torture_suite *suite = torture_suite_create(
+               talloc_autofree_context(),
+               "RPC");
+
+       return suite;
+}
+
+/**
+ * DRSUAPI tests to be executed remotely
+ */
+static struct torture_suite * torture_drs_unit_suite(TALLOC_CTX *mem_ctx)
+{
+       struct torture_suite *suite = torture_suite_create(
+               talloc_autofree_context(),
+               "UNIT");
+
+       torture_drs_unit_prefixmap(suite);
+
+       return suite;
+}
+
+/**
+ * DRSUAPI torture module initialization
+ */
+NTSTATUS torture_drs_init(void)
+{
+       struct torture_suite *suite = torture_suite_create(
+               talloc_autofree_context(),
+               "DRS");
+
+       torture_suite_add_suite(suite, torture_drs_rpc_suite(suite));
+       torture_suite_add_suite(suite, torture_drs_unit_suite(suite));
+
+       suite->description = talloc_strdup(suite,
+                                          "DRSUAPI related tests - Remote and Local");
+
+       torture_register_suite(suite);
+
+       return NT_STATUS_OK;
+}

diff --git a/source4/torture/drs/drs_util.c b/source4/torture/drs/drs_util.c
new file mode 100644 (file)
index 0000000..093fcf8
--- /dev/null
+++ b/source4/torture/drs/drs_util.c
@@ -0,0 +1,168 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DRSUAPI utility functions to be used in torture tests
+
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "torture/torture.h"
+#include "torture/rpc/drsuapi.h"
+#include "../lib/util/asn1.h"
+
+/**
+ * Decode Attribute OID based on MS documentation
+ * See MS-DRSR.pdf - 5.16.4
+ *
+ * On success returns decoded OID and
+ * corresponding prefix_map index (if requested)
+ */
+bool drs_util_oid_from_attid(struct torture_context *tctx,
+                            struct drsuapi_DsReplicaOIDMapping_Ctr *prefix_map,
+                            uint32_t attid,
+                            const char **_oid,
+                            int *map_idx)
+{
+       int i;
+       uint32_t hi_word, lo_word;
+       DATA_BLOB bin_oid = {NULL, 0};
+       struct drsuapi_DsReplicaOIDMapping *map_entry = NULL;
+       TALLOC_CTX *mem_ctx = talloc_named(tctx, 0, "util_drsuapi_oid_from_attid");
+
+       /* crack attid value */
+       hi_word = attid >> 16;
+       lo_word = attid & 0xFFFF;
+
+       /* check last entry in the prefix map is the special one */
+       map_entry = &prefix_map->mappings[prefix_map->num_mappings-1];
+       torture_assert(tctx,
+                       (map_entry->id_prefix == 0)
+                       && (*map_entry->oid.binary_oid == 0xFF),
+                       "Last entry in Prefix Map is not the special one!");
+
+       /* locate correspoding prefixMap entry */
+       map_entry = NULL;
+       for (i = 0; i < prefix_map->num_mappings - 1; i++) {
+
+               if (hi_word == prefix_map->mappings[i].id_prefix) {
+                       map_entry = &prefix_map->mappings[i];
+                       if (map_idx)    *map_idx = i;
+                       break;
+               }
+       }
+
+       torture_assert(tctx, map_entry, "Unable to locate corresponding Prefix Map entry");
+
+       /* copy partial oid making enough room */
+       bin_oid.length = map_entry->oid.length + 2;
+       bin_oid.data = talloc_array(mem_ctx, uint8_t, bin_oid.length);
+       torture_assert(tctx, bin_oid.data, "Not enough memory");
+       memcpy(bin_oid.data, map_entry->oid.binary_oid, map_entry->oid.length);
+
+       if (lo_word < 128) {
+               bin_oid.length = bin_oid.length - 1;
+               bin_oid.data[bin_oid.length-1] = lo_word;
+       }
+       else {
+               if (lo_word == 32768) {
+                       lo_word -= 32768;
+               }
+               bin_oid.data[bin_oid.length-2] = ((lo_word / 128) % 128) + 128; // (0x80 | ((lo_word>>7)&0x7f))
+               bin_oid.data[bin_oid.length-1] = lo_word % 128; // lo_word & 0x7f
+       }
+
+       torture_assert(tctx,
+                       ber_read_OID_String(tctx, bin_oid, _oid),
+                       "Failed to decode binary OID");
+       talloc_free(mem_ctx);
+
+       return true;
+}
+
+/**
+ * Utility function to convert drsuapi_DsAttributeId to String
+ */
+const char * drs_util_DsAttributeId_to_string(enum drsuapi_DsAttributeId r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+       case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
+       case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
+       case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
+       case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
+       case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
+       case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
+       case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
+       case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
+       case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
+       case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
+       case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
+       case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
+       case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
+       case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
+       case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
+       case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
+       case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
+       case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
+       case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
+       case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
+       case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
+       case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
+       case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
+       case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
+       case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
+       case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
+       case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
+       case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
+       case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
+       case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
+       case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
+       case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
+       case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
+       case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
+       case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
+       case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
+       case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
+       case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
+       case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
+       case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
+       case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
+       case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
+       case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
+       case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
+       case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
+       case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
+       case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
+       case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
+       case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
+       case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
+       case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
+       case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
+       case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
+       case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
+       case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
+       case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
+       case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
+       case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
+       case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
+       case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
+       case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
+       default: val = "UNKNOWN_ENUM_VALUE"; break;
+       }
+       return val;
+}

diff --git a/source4/torture/drs/internal/prefixmap_tests.c b/source4/torture/drs/internal/prefixmap_tests.c
new file mode 100644 (file)
index 0000000..00a4312
--- /dev/null
+++ b/source4/torture/drs/internal/prefixmap_tests.c
@@ -0,0 +1,80 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DRSUAPI prefixMap unit tests
+
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "torture/smbtorture.h"
+#include "torture/rpc/drsuapi.h"
+#include "torture/drs/proto.h"
+#include "dsdb/samdb/samdb.h"
+#include "dsdb/schema/prefixmap.h"
+
+
+/**
+ * Private data to be shared among all test in Test case
+ */
+struct drsut_prefixmap_data {
+       struct dsdb_schema_prefixmap *prefixmap;
+};
+
+
+/**
+ * Initial prefix map creation function
+ *
+ */
+static struct dsdb_schema_prefixmap * _drsut_prefixmap_new(struct torture_context *tctx)
+{
+       return NULL;
+}
+
+/*
+ * Setup/Teardown for test case
+ */
+static bool torture_drs_unit_prefixmap_setup(struct torture_context *tctx, struct drsut_prefixmap_data **priv)
+{
+       *priv = talloc_zero(tctx, struct drsut_prefixmap_data);
+       (*priv)->prefixmap = _drsut_prefixmap_new(tctx);
+       return true;
+}
+
+static bool torture_drs_unit_prefixmap_teardown(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
+{
+       return true;
+}
+
+/**
+ * Test case initialization for
+ * DRS-UNIT.prefixMap
+ */
+struct torture_tcase * torture_drs_unit_prefixmap(struct torture_suite *suite)
+{
+       typedef bool (*pfn_setup)(struct torture_context *, void **);
+       typedef bool (*pfn_teardown)(struct torture_context *, void *);
+
+       struct torture_tcase * tc = torture_suite_add_tcase(suite, "prefixMap");
+
+       torture_tcase_set_fixture(tc,
+                                 (pfn_setup)torture_drs_unit_prefixmap_setup,
+                                 (pfn_teardown)torture_drs_unit_prefixmap_teardown);
+
+       tc->description = talloc_strdup(tc, "Unit tests for DRSUAPI::prefixMap implementation");
+
+       return tc;
+}

diff --git a/source4/torture/gentest.c b/source4/torture/gentest.c
index be02f33378a45f4d33b262aa0d949a4a0b567131..3d23ad85bc0d3c5fb6cb9ec36598c04b89166f25 100644 (file)
--- a/source4/torture/gentest.c
+++ b/source4/torture/gentest.c
@@ -1819,7 +1819,7 @@ static bool handler_smb_ntcreatex(int instance)
 
        parm[0].ntcreatex.level = RAW_OPEN_NTCREATEX;
        parm[0].ntcreatex.in.flags = gen_ntcreatex_flags();
-       parm[0].ntcreatex.in.root_fid = gen_root_fid(instance);
+       parm[0].ntcreatex.in.root_fid.fnum = gen_root_fid(instance);
        parm[0].ntcreatex.in.access_mask = gen_access_mask();
        parm[0].ntcreatex.in.alloc_size = gen_alloc_size();
        parm[0].ntcreatex.in.file_attr = gen_attrib();
@@ -1837,8 +1837,8 @@ static bool handler_smb_ntcreatex(int instance)
        }
        
        GEN_COPY_PARM;
-       if (parm[0].ntcreatex.in.root_fid != 0) {
-               GEN_SET_FNUM_SMB(ntcreatex.in.root_fid);
+       if (parm[0].ntcreatex.in.root_fid.fnum != 0) {
+               GEN_SET_FNUM_SMB(ntcreatex.in.root_fid.fnum);
        }
        GEN_CALL_SMB(smb_raw_open(tree, current_op.mem_ctx, &parm[i]));
 

diff --git a/source4/torture/ldap/basic.c b/source4/torture/ldap/basic.c
index c2a26f81b8cdce3cbb7b2ce3993a16c171a96bff..a9d9ea083282b204593dfacd78a6218380630abc 100644 (file)
--- a/source4/torture/ldap/basic.c
+++ b/source4/torture/ldap/basic.c
@@ -213,7 +213,8 @@ static bool test_error_codes(struct torture_context *tctx,
 {
        struct ldap_message *msg, *rep;
        struct ldap_request *req;
-       char *err_code_str, *endptr;
+       const char *err_code_str;
+       char *endptr;
        WERROR err;
        NTSTATUS status;
 
@@ -263,8 +264,8 @@ static bool test_error_codes(struct torture_context *tctx,
                        return false;
                }
        } else {
-               if ((!W_ERROR_EQUAL(err, WERR_DS_GENERIC_ERROR))
-                       || (rep->r.AddResponse.resultcode != 80)) {
+               if ((!W_ERROR_EQUAL(err, WERR_DS_OBJ_CLASS_VIOLATION))
+                       || (rep->r.AddResponse.resultcode != 65)) {
                        return false;
                }
        }
@@ -304,8 +305,8 @@ static bool test_error_codes(struct torture_context *tctx,
                        return false;
                }
        } else {
-               if ((!W_ERROR_EQUAL(err, WERR_DS_GENERIC_ERROR))
-                       || (rep->r.ModifyResponse.resultcode != 80)) {
+               if ((!W_ERROR_EQUAL(err, WERR_DS_OPERATIONS_ERROR))
+                       || (rep->r.ModifyResponse.resultcode != 1)) {
                        return false;
                }
        }

diff --git a/source4/torture/ldap/cldap.c b/source4/torture/ldap/cldap.c
index d0e971918832d2b0b66d035c8d41216487ac5c85..5e5b3744fed585d1dca7d60da83428722de59cbd 100644 (file)
--- a/source4/torture/ldap/cldap.c
+++ b/source4/torture/ldap/cldap.c
@@ -194,6 +194,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
        search.in.user = "Administrator";
        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
        CHECK_STATUS(status, NT_STATUS_OK);
+       CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
 
@@ -201,8 +202,9 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
        search.in.user = "___no_such_user___";
        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
        CHECK_STATUS(status, NT_STATUS_OK);
-       CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
+       CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+       CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
 
        printf("Trying with just a bad domain\n");
@@ -215,6 +217,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
        search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
        CHECK_STATUS(status, NT_STATUS_OK);
+       CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
@@ -223,6 +226,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
        search.in.domain_guid = GUID_string(tctx, &guid);
        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
        CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
+       CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
@@ -232,6 +236,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
        search.in.realm = n1.data.nt5_ex.dns_domain;
        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
        CHECK_STATUS(status, NT_STATUS_OK);
+       CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
@@ -303,8 +308,8 @@ static bool test_cldap_netlogon_flags(struct torture_context *tctx,
                printf("DS_DNS_CONTROLLER ");
        if (server_type & DS_DNS_DOMAIN)
                printf("DS_DNS_DOMAIN ");
-       if (server_type & DS_DNS_FOREST)
-               printf("DS_DNS_FOREST ");
+       if (server_type & DS_DNS_FOREST_ROOT)
+               printf("DS_DNS_FOREST_ROOT ");
 
        printf("\n");
 
@@ -352,7 +357,7 @@ static void cldap_dump_results(struct cldap_search *search)
 
 
 /*
-  test cldap netlogon server type flag "NBT_SERVER_DS_DNS_FOREST"
+  test cldap netlogon server type flag "NBT_SERVER_FOREST_ROOT"
 */
 static bool test_cldap_netlogon_flag_ds_dns_forest(struct torture_context *tctx,
        const char *dest)
@@ -369,7 +374,7 @@ static bool test_cldap_netlogon_flag_ds_dns_forest(struct torture_context *tctx,
        status = cldap_socket_init(tctx, NULL, NULL, NULL, &cldap);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("Testing netlogon server type flag NBT_SERVER_DS_DNS_FOREST: ");
+       printf("Testing netlogon server type flag NBT_SERVER_FOREST_ROOT: ");
 
        ZERO_STRUCT(search);
        search.in.dest_address = dest;
@@ -387,7 +392,7 @@ static bool test_cldap_netlogon_flag_ds_dns_forest(struct torture_context *tctx,
        else if (n1.ntver == NETLOGON_NT_VERSION_5EX)
                server_type = n1.data.nt5_ex.server_type;
 
-       if (server_type & DS_DNS_FOREST) {
+       if (server_type & DS_DNS_FOREST_ROOT) {
                struct cldap_search search2;
                const char *attrs[] = { "defaultNamingContext", "rootDomainNamingContext", 
                        NULL };

diff --git a/source4/torture/ldb/ldb.c b/source4/torture/ldb/ldb.c
index 64ed669fc18352ec5d4e2d0cb08d13290ad77902..23c9bb23331942d0e5636fde1680207b50411e07 100644 (file)
--- a/source4/torture/ldb/ldb.c
+++ b/source4/torture/ldb/ldb.c
@@ -31,10 +31,10 @@
 #include "torture/local/proto.h"
 
 static const char *sid = "S-1-5-21-4177067393-1453636373-93818737";
-static const char *hex_sid = "01040000000000051500000081FDF8F815BBA456718F9705";
+static const char *hex_sid = "01040000000000051500000081fdf8f815bba456718f9705";
 static const char *guid = "975ac5fa-35d9-431d-b86a-845bcd34fff9";
 static const char *guid2 = "{975ac5fa-35d9-431d-b86a-845bcd34fff9}";
-static const char *hex_guid = "FAC55A97D9351D43B86A845BCD34FFF9";
+static const char *hex_guid = "fac55a97d9351d43b86a845bcd34fff9";
 
 static const char *prefix_map_newline = "2:1.2.840.113556.1.2\n5:2.16.840.1.101.2.2.3";
 static const char *prefix_map_semi = "2:1.2.840.113556.1.2;5:2.16.840.1.101.2.2.3";
@@ -671,19 +671,6 @@ static bool torture_ldb_dn(struct torture_context *torture)
                       NULL == ldb_dn_from_ldb_val(mem_ctx, ldb, &val),
                       "should fail to create a DN with 0x0 in it");
 
-       torture_assert(torture,
-                      dn = ldb_dn_new(mem_ctx, ldb, "CN=loooooooooooooooooooooooooooo"
-"ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
-"ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
-"ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
-"ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
-"ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongdn,DC=SAMBA,DC=org"),
-                      "Failed to create a DN with size more than 255 characters");
-
-       torture_assert(torture,
-                      ldb_dn_validate(dn) == false,
-                      "should have failed to validate DN with size more than 255 characters");
-
        talloc_free(mem_ctx);
        return true;
 }

diff --git a/source4/torture/local/config.mk b/source4/torture/local/config.mk
index 1c3a721ac94e2b8b38422b5431920c5a32d7bee4..7633d6c4dbd65050731363749ffaca73f9644b2e 100644 (file)
--- a/source4/torture/local/config.mk
+++ b/source4/torture/local/config.mk
@@ -41,6 +41,7 @@ TORTURE_LOCAL_OBJ_FILES = \
                $(torturesrcdir)/../../lib/util/tests/parmlist.o \
                $(torturesrcdir)/../../lib/util/tests/str.o \
                $(torturesrcdir)/../../lib/util/tests/time.o \
+               $(torturesrcdir)/../../lib/util/tests/asn1_tests.o \
                $(torturesrcdir)/../../lib/util/tests/data_blob.o \
                $(torturesrcdir)/../../lib/util/tests/file.o \
                $(torturesrcdir)/../../lib/util/tests/genrand.o \

diff --git a/source4/torture/local/local.c b/source4/torture/local/local.c
index 4180d308da1cf0da05e72343012aebf1cd5a85ba..8c6fd5e10c926112b9fb63c99323789c9119e469 100644 (file)
--- a/source4/torture/local/local.c
+++ b/source4/torture/local/local.c
@@ -39,6 +39,7 @@
        torture_local_util_str, 
        torture_local_util_time, 
        torture_local_util_data_blob, 
+       torture_local_util_asn1,
        torture_local_idtree, 
        torture_local_genrand, 
        torture_local_iconv,

diff --git a/source4/torture/nbench/nbio.c b/source4/torture/nbench/nbio.c
index bf594088cd746b94832f350e4400544875eb711b..0f811ab56e9ca65f7b1d4725357ef3546c9cecce 100644 (file)
--- a/source4/torture/nbench/nbio.c
+++ b/source4/torture/nbench/nbio.c
@@ -487,7 +487,7 @@ static bool nb_do_createx(struct ftable *f,
 
        io.ntcreatex.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = flags;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = desired_access;
        io.ntcreatex.in.file_attr = 0;
        io.ntcreatex.in.alloc_size = 0;

diff --git a/source4/torture/raw/acls.c b/source4/torture/raw/acls.c
index 48dec6e561301d7bcc8946c6c2006a90c567962f..8fde373dce8cbcfe1c6866b77c595b3df8271b06 100644 (file)
--- a/source4/torture/raw/acls.c
+++ b/source4/torture/raw/acls.c
@@ -57,7 +57,7 @@ static bool test_sd(struct torture_context *tctx,
        printf("TESTING SETFILEINFO EA_SET\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -161,7 +161,7 @@ static bool test_nttrans_create(struct torture_context *tctx,
        printf("testing nttrans create with sec_desc\n");
 
        io.generic.level = RAW_OPEN_NTTRANS_CREATE;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -267,7 +267,7 @@ static bool test_nttrans_create_null_dacl(struct torture_context *tctx,
        printf("TESTING SEC_DESC WITH A NULL DACL\n");
 
        io.generic.level = RAW_OPEN_NTTRANS_CREATE;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_STD_READ_CONTROL | SEC_STD_WRITE_DAC
                | SEC_STD_WRITE_OWNER;
@@ -512,7 +512,7 @@ static bool test_creator_sid(struct torture_context *tctx,
        printf("TESTING SID_CREATOR_OWNER\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_STD_READ_CONTROL | SEC_STD_WRITE_DAC | SEC_STD_WRITE_OWNER;
        io.ntcreatex.in.create_options = 0;
@@ -748,7 +748,7 @@ static bool test_generic_bits(struct torture_context *tctx,
        printf("TESTING FILE GENERIC BITS\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = 
                SEC_STD_READ_CONTROL | 
@@ -778,21 +778,21 @@ static bool test_generic_bits(struct torture_context *tctx,
 
        owner_sid = dom_sid_string(tctx, sd_orig->owner_sid);
 
-       status = smblsa_sid_check_privilege(cli, 
+       status = torture_check_privilege(cli, 
                                            owner_sid, 
                                            sec_privilege_name(SEC_PRIV_RESTORE));
        has_restore_privilege = NT_STATUS_IS_OK(status);
        if (!NT_STATUS_IS_OK(status)) {
-               printf("smblsa_sid_check_privilege - %s\n", nt_errstr(status));
+               printf("torture_check_privilege - %s\n", nt_errstr(status));
        }
        printf("SEC_PRIV_RESTORE - %s\n", has_restore_privilege?"Yes":"No");
 
-       status = smblsa_sid_check_privilege(cli, 
+       status = torture_check_privilege(cli, 
                                            owner_sid, 
                                            sec_privilege_name(SEC_PRIV_TAKE_OWNERSHIP));
        has_take_ownership_privilege = NT_STATUS_IS_OK(status);
        if (!NT_STATUS_IS_OK(status)) {
-               printf("smblsa_sid_check_privilege - %s\n", nt_errstr(status));
+               printf("torture_check_privilege - %s\n", nt_errstr(status));
        }
        printf("SEC_PRIV_TAKE_OWNERSHIP - %s\n", has_take_ownership_privilege?"Yes":"No");
 
@@ -913,7 +913,7 @@ static bool test_generic_bits(struct torture_context *tctx,
        printf("TESTING DIR GENERIC BITS\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = 
                SEC_STD_READ_CONTROL | 
@@ -943,21 +943,21 @@ static bool test_generic_bits(struct torture_context *tctx,
 
        owner_sid = dom_sid_string(tctx, sd_orig->owner_sid);
 
-       status = smblsa_sid_check_privilege(cli, 
+       status = torture_check_privilege(cli, 
                                            owner_sid, 
                                            sec_privilege_name(SEC_PRIV_RESTORE));
        has_restore_privilege = NT_STATUS_IS_OK(status);
        if (!NT_STATUS_IS_OK(status)) {
-               printf("smblsa_sid_check_privilege - %s\n", nt_errstr(status));
+               printf("torture_check_privilege - %s\n", nt_errstr(status));
        }
        printf("SEC_PRIV_RESTORE - %s\n", has_restore_privilege?"Yes":"No");
 
-       status = smblsa_sid_check_privilege(cli, 
+       status = torture_check_privilege(cli, 
                                            owner_sid, 
                                            sec_privilege_name(SEC_PRIV_TAKE_OWNERSHIP));
        has_take_ownership_privilege = NT_STATUS_IS_OK(status);
        if (!NT_STATUS_IS_OK(status)) {
-               printf("smblsa_sid_check_privilege - %s\n", nt_errstr(status));
+               printf("torture_check_privilege - %s\n", nt_errstr(status));
        }
        printf("SEC_PRIV_TAKE_OWNERSHIP - %s\n", has_take_ownership_privilege?"Yes":"No");
 
@@ -1102,7 +1102,7 @@ static bool test_owner_bits(struct torture_context *tctx,
        printf("TESTING FILE OWNER BITS\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = 
                SEC_STD_READ_CONTROL | 
@@ -1132,21 +1132,21 @@ static bool test_owner_bits(struct torture_context *tctx,
 
        owner_sid = dom_sid_string(tctx, sd_orig->owner_sid);
 
-       status = smblsa_sid_check_privilege(cli, 
+       status = torture_check_privilege(cli, 
                                            owner_sid, 
                                            sec_privilege_name(SEC_PRIV_RESTORE));
        has_restore_privilege = NT_STATUS_IS_OK(status);
        if (!NT_STATUS_IS_OK(status)) {
-               printf("smblsa_sid_check_privilege - %s\n", nt_errstr(status));
+               printf("torture_check_privilege - %s\n", nt_errstr(status));
        }
        printf("SEC_PRIV_RESTORE - %s\n", has_restore_privilege?"Yes":"No");
 
-       status = smblsa_sid_check_privilege(cli, 
+       status = torture_check_privilege(cli, 
                                            owner_sid, 
                                            sec_privilege_name(SEC_PRIV_TAKE_OWNERSHIP));
        has_take_ownership_privilege = NT_STATUS_IS_OK(status);
        if (!NT_STATUS_IS_OK(status)) {
-               printf("smblsa_sid_check_privilege - %s\n", nt_errstr(status));
+               printf("torture_check_privilege - %s\n", nt_errstr(status));
        }
        printf("SEC_PRIV_TAKE_OWNERSHIP - %s\n", has_take_ownership_privilege?"Yes":"No");
 
@@ -1219,7 +1219,7 @@ static bool test_inheritance(struct torture_context *tctx,
        union smb_fileinfo q;
        union smb_setfileinfo set;
        struct security_descriptor *sd, *sd2, *sd_orig=NULL, *sd_def;
-       const char *owner_sid;
+       const char *owner_sid, *group_sid;
        const struct dom_sid *creator_owner;
        const struct {
                uint32_t parent_flags;
@@ -1334,7 +1334,7 @@ static bool test_inheritance(struct torture_context *tctx,
        printf("TESTING ACL INHERITANCE\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1353,26 +1353,54 @@ static bool test_inheritance(struct torture_context *tctx,
        printf("get the original sd\n");
        q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
        q.query_secdesc.in.file.fnum = fnum;
-       q.query_secdesc.in.secinfo_flags = SECINFO_DACL | SECINFO_OWNER;
+       q.query_secdesc.in.secinfo_flags = SECINFO_DACL | SECINFO_OWNER | SECINFO_GROUP;
        status = smb_raw_fileinfo(cli->tree, tctx, &q);
        CHECK_STATUS(status, NT_STATUS_OK);
        sd_orig = q.query_secdesc.out.sd;
 
        owner_sid = dom_sid_string(tctx, sd_orig->owner_sid);
+       group_sid = dom_sid_string(tctx, sd_orig->group_sid);
 
        printf("owner_sid is %s\n", owner_sid);
+       printf("group_sid is %s\n", group_sid);
+
+       q.query_secdesc.in.secinfo_flags = SECINFO_DACL | SECINFO_OWNER;
 
-       sd_def = security_descriptor_dacl_create(tctx,
-                                           0, owner_sid, NULL,
-                                           owner_sid,
-                                           SEC_ACE_TYPE_ACCESS_ALLOWED,
-                                           SEC_RIGHTS_FILE_ALL,
-                                           0,
-                                           SID_NT_SYSTEM,
-                                           SEC_ACE_TYPE_ACCESS_ALLOWED,
-                                           SEC_RIGHTS_FILE_ALL,
-                                           0,
-                                           NULL);
+       if (torture_setting_bool(tctx, "samba4", false)) {
+               /* the default ACL in Samba4 includes the group and
+                  other permissions */
+               sd_def = security_descriptor_dacl_create(tctx,
+                                                        0, owner_sid, NULL,
+                                                        owner_sid,
+                                                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                                                        SEC_RIGHTS_FILE_ALL,
+                                                        0,
+                                                        group_sid,
+                                                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                                                        SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE,
+                                                        0,
+                                                        SID_WORLD,
+                                                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                                                        SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE,
+                                                        0,
+                                                        SID_NT_SYSTEM,
+                                                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                                                        SEC_RIGHTS_FILE_ALL,
+                                                        0,
+                                                        NULL);
+       } else {
+               sd_def = security_descriptor_dacl_create(tctx,
+                                                        0, owner_sid, NULL,
+                                                        owner_sid,
+                                                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                                                        SEC_RIGHTS_FILE_ALL,
+                                                        0,
+                                                        SID_NT_SYSTEM,
+                                                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                                                        SEC_RIGHTS_FILE_ALL,
+                                                        0,
+                                                        NULL);
+       }
 
        creator_owner = dom_sid_parse_talloc(tctx, SID_CREATOR_OWNER);
 
@@ -1410,7 +1438,7 @@ static bool test_inheritance(struct torture_context *tctx,
 
                if (!(test_flags[i].parent_flags & SEC_ACE_FLAG_OBJECT_INHERIT)) {
                        if (!security_descriptor_equal(q.query_secdesc.out.sd, sd_def)) {
-                               printf("Expected default sd:\n");
+                               printf(__location__ ": Expected default sd for i=%d:\n", i);
                                NDR_PRINT_DEBUG(security_descriptor, sd_def);
                                printf("at %d - got:\n", i);
                                NDR_PRINT_DEBUG(security_descriptor, q.query_secdesc.out.sd);
@@ -1639,8 +1667,8 @@ static bool test_inheritance_dynamic(struct torture_context *tctx,
 {
        NTSTATUS status;
        union smb_open io;
-       const char *dname = BASEDIR "\\inheritance";
-       const char *fname1 = BASEDIR "\\inheritance\\testfile";
+       const char *dname = BASEDIR "\\inheritance2";
+       const char *fname1 = BASEDIR "\\inheritance2\\testfile";
        bool ret = true;
        int fnum=0, fnum2;
        union smb_fileinfo q;
@@ -1655,7 +1683,7 @@ static bool test_inheritance_dynamic(struct torture_context *tctx,
        }
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1848,7 +1876,7 @@ static bool test_sd_get_set(struct torture_context *tctx,
        sd->type |= SEC_DESC_SACL_PRESENT;
        sd->sacl = NULL;
        io.ntcreatex.level = RAW_OPEN_NTTRANS_CREATE;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_GENERIC_ALL;
        io.ntcreatex.in.create_options = 0;

diff --git a/source4/torture/raw/context.c b/source4/torture/raw/context.c
index a9d36b7788c9f9a19963c063c0a63baf3d6ea930..0e0851e7412b759c5221208bec9ca3bcc4e1f24f 100644 (file)
--- a/source4/torture/raw/context.c
+++ b/source4/torture/raw/context.c
@@ -175,7 +175,7 @@ static bool test_session(struct smbcli_state *cli, struct torture_context *tctx)
 
        printf("create a file using the new vuid\n");
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -311,7 +311,7 @@ static bool test_tree(struct smbcli_state *cli, struct torture_context *tctx)
 
        printf("create a file using the new tid\n");
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -425,7 +425,7 @@ static bool test_tree_ulogoff(struct smbcli_state *cli, struct torture_context *
 
        printf("create a file using vuid1\n");
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -473,7 +473,7 @@ static bool test_tree_ulogoff(struct smbcli_state *cli, struct torture_context *
 
        printf("create a file using vuid2\n");
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -551,7 +551,7 @@ static bool test_pid_exit_only_sees_open(struct smbcli_state *cli, TALLOC_CTX *m
        printf("create a file using pid1\n");
        cli->session->pid = pid1;
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -677,7 +677,7 @@ static bool test_pid_2sess(struct smbcli_state *cli, struct torture_context *tct
        printf("create a file using the vuid1\n");
        cli->session->vuid = vuid1;
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -785,7 +785,7 @@ static bool test_pid_2tcon(struct smbcli_state *cli, struct torture_context *tct
        printf("create a file using the tid1\n");
        cli->tree->tid = tid1;
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -816,7 +816,7 @@ static bool test_pid_2tcon(struct smbcli_state *cli, struct torture_context *tct
        printf("create a file using the tid2\n");
        cli->tree->tid = tid2;
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;

diff --git a/source4/torture/raw/eas.c b/source4/torture/raw/eas.c
index 49a81dd5345026e167c0e51caf5a92a6a16afd3a..32ceba119a2f50524ae57dee45111560f09b7a6f 100644 (file)
--- a/source4/torture/raw/eas.c
+++ b/source4/torture/raw/eas.c
@@ -57,7 +57,7 @@ static bool test_eas(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        printf("TESTING SETFILEINFO EA_SET\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -282,7 +282,7 @@ static bool test_max_eas(struct smbcli_state *cli, struct torture_context *tctx)
               maxeadebug);
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -375,7 +375,7 @@ static bool test_nttrans_create(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        printf("TESTING NTTRANS CREATE WITH EAS\n");
 
        io.generic.level = RAW_OPEN_NTTRANS_CREATE;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;

diff --git a/source4/torture/raw/mux.c b/source4/torture/raw/mux.c
index 5b5db3a55726f80c870ed082d830fa80464e4899..19cb4ce422eed2b6d3a7dc55716275e68f666ca3 100644 (file)
--- a/source4/torture/raw/mux.c
+++ b/source4/torture/raw/mux.c
@@ -53,7 +53,7 @@ static bool test_mux_open(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 
        printf("send first open\n");
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA;
        io.ntcreatex.in.create_options = 0;

diff --git a/source4/torture/raw/notify.c b/source4/torture/raw/notify.c
index c92170cf619037d3e1e385bd52564c58351995fe..8be7e06dff9e4713a836ee4193d2d5bdbfe3ae78 100644 (file)
--- a/source4/torture/raw/notify.c
+++ b/source4/torture/raw/notify.c
@@ -73,7 +73,7 @@ static bool test_notify_dir(struct smbcli_state *cli, struct smbcli_state *cli2,
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -310,7 +310,7 @@ static bool test_notify_recursive(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -441,7 +441,7 @@ static bool test_notify_mask_change(struct smbcli_state *cli, TALLOC_CTX *mem_ct
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -566,7 +566,7 @@ static bool test_notify_mask(struct smbcli_state *cli, struct torture_context *t
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -793,7 +793,7 @@ static bool test_notify_file(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        printf("TESTING CHANGE NOTIFY ON FILES\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        io.ntcreatex.in.create_options = 0;
@@ -859,7 +859,7 @@ static bool test_notify_tdis(struct torture_context *tctx)
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -921,7 +921,7 @@ static bool test_notify_exit(struct torture_context *tctx)
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -982,7 +982,7 @@ static bool test_notify_ulogoff(struct torture_context *tctx)
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1050,7 +1050,7 @@ static bool test_notify_tcp_dis(struct torture_context *tctx)
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1104,7 +1104,7 @@ static bool test_notify_double(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1197,7 +1197,7 @@ static bool test_notify_tree(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        printf("TESTING CHANGE NOTIFY FOR DIFFERENT DEPTHS\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1293,7 +1293,7 @@ static bool test_notify_overflow(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        NTSTATUS status;
        union smb_notify notify;
        union smb_open io;
-       int fnum, fnum2;
+       int fnum;
        int count = 100;
        struct smbcli_request *req1;
        int i;
@@ -1302,7 +1302,7 @@ static bool test_notify_overflow(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 
        /* get a handle on the directory */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1371,16 +1371,14 @@ static bool test_notify_basedir(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
        NTSTATUS status;
        union smb_notify notify;
        union smb_open io;
-       int fnum, fnum2;
-       int count = 100;
+       int fnum;
        struct smbcli_request *req1;
-       int i;
 
        printf("TESTING CHANGE NOTIFY BASEDIR EVENTS\n");
 
        /* get a handle on the directory */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -1487,7 +1485,7 @@ static bool test_notify_tcon(struct smbcli_state *cli, struct torture_context *t
          get a handle on the directory
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;

diff --git a/source4/torture/raw/open.c b/source4/torture/raw/open.c
index 9f35aae4d0a87de2a9a5152e583a61a67408d9eb..73f9c3f839e2bb5675e108379b5857ae6371af10 100644 (file)
--- a/source4/torture/raw/open.c
+++ b/source4/torture/raw/open.c
@@ -65,7 +65,8 @@ static const char *rdwr_string(enum rdwr_mode m)
 
 #define CHECK_STATUS(status, correct) do { \
        if (!NT_STATUS_EQUAL(status, correct)) { \
-               printf("(%s) Incorrect status %s - should be %s\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                       "(%s) Incorrect status %s - should be %s\n", \
                       __location__, nt_errstr(status), nt_errstr(correct)); \
                ret = false; \
                goto done; \
@@ -74,7 +75,9 @@ static const char *rdwr_string(enum rdwr_mode m)
 #define CREATE_FILE do { \
        fnum = create_complex_file(cli, tctx, fname); \
        if (fnum == -1) { \
-               printf("(%s) Failed to create %s - %s\n", __location__, fname, smbcli_errstr(cli->tree)); \
+               torture_result(tctx, TORTURE_FAIL, \
+                       "(%s) Failed to create %s - %s\n", \
+                        __location__, fname, smbcli_errstr(cli->tree)); \
                ret = false; \
                goto done; \
        }} while (0)
@@ -82,7 +85,8 @@ static const char *rdwr_string(enum rdwr_mode m)
 #define CHECK_RDWR(fnum, correct) do { \
        enum rdwr_mode m = check_rdwr(cli->tree, fnum); \
        if (m != correct) { \
-               printf("(%s) Incorrect readwrite mode %s - expected %s\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                      "(%s) Incorrect readwrite mode %s - expected %s\n", \
                       __location__, rdwr_string(m), rdwr_string(correct)); \
                ret = false; \
        }} while (0)
@@ -96,7 +100,8 @@ static const char *rdwr_string(enum rdwr_mode m)
        t1 = t & ~1; \
        t2 = nt_time_to_unix(finfo.all_info.out.field) & ~1; \
        if (abs(t1-t2) > 2) { \
-               printf("(%s) wrong time for field %s  %s - %s\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                      "(%s) wrong time for field %s  %s - %s\n", \
                       __location__, #field, \
                       timestring(tctx, t1), \
                       timestring(tctx, t2)); \
@@ -112,7 +117,8 @@ static const char *rdwr_string(enum rdwr_mode m)
        CHECK_STATUS(status, NT_STATUS_OK); \
        t2 = finfo.all_info.out.field; \
        if (t != t2) { \
-               printf("(%s) wrong time for field %s  %s - %s\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                      "(%s) wrong time for field %s  %s - %s\n", \
                       __location__, #field, \
                       nt_time_string(tctx, t), \
                       nt_time_string(tctx, t2)); \
@@ -126,7 +132,8 @@ static const char *rdwr_string(enum rdwr_mode m)
        status = smb_raw_pathinfo(cli->tree, tctx, &finfo); \
        CHECK_STATUS(status, NT_STATUS_OK); \
        if ((v) != (finfo.all_info.out.field)) { \
-               printf("(%s) wrong value for field %s  0x%x - 0x%x\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                      "(%s) wrong value for field %s  0x%x - 0x%x\n", \
                       __location__, #field, (int)v, (int)(finfo.all_info.out.field)); \
                dump_all_info(tctx, &finfo); \
                ret = false; \
@@ -134,7 +141,8 @@ static const char *rdwr_string(enum rdwr_mode m)
 
 #define CHECK_VAL(v, correct) do { \
        if ((v) != (correct)) { \
-               printf("(%s) wrong value for %s  0x%x - should be 0x%x\n", \
+               torture_result(tctx, TORTURE_FAIL, \
+                      "(%s) wrong value for %s  0x%x - should be 0x%x\n", \
                       __location__, #v, (int)(v), (int)correct); \
                ret = false; \
        }} while (0)
@@ -147,7 +155,7 @@ static const char *rdwr_string(enum rdwr_mode m)
        sfinfo.basic_info.in.attrib = sattrib; \
        status = smb_raw_setpathinfo(cli->tree, &sfinfo); \
        if (!NT_STATUS_IS_OK(status)) { \
-               printf("(%s) Failed to set attrib 0x%x on %s\n", \
+               torture_warning(tctx, "(%s) Failed to set attrib 0x%x on %s\n", \
                       __location__, sattrib, fname); \
        }} while (0)
 
@@ -163,7 +171,7 @@ static bool test_open(struct smbcli_state *cli, struct torture_context *tctx)
        int fnum = -1, fnum2;
        bool ret = true;
 
-       printf("Checking RAW_OPEN_OPEN\n");
+       torture_comment(tctx, "Checking RAW_OPEN_OPEN\n");
 
        io.openold.level = RAW_OPEN_OPEN;
        io.openold.in.fname = fname;
@@ -223,7 +231,7 @@ static bool test_open(struct smbcli_state *cli, struct torture_context *tctx)
        CHECK_RDWR(fnum, RDWR_RDWR);
        
        if (io.openold.in.open_mode != io.openold.out.rmode) {
-               printf("(%s) rmode should equal open_mode - 0x%x 0x%x\n",
+               torture_warning(tctx, "(%s) rmode should equal open_mode - 0x%x 0x%x\n",
                       __location__, io.openold.out.rmode, io.openold.in.open_mode);
        }
 
@@ -295,7 +303,7 @@ static bool test_openx(struct smbcli_state *cli, struct torture_context *tctx)
                { OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OK },
        };
 
-       printf("Checking RAW_OPEN_OPENX\n");
+       torture_comment(tctx, "Checking RAW_OPEN_OPENX\n");
        smbcli_unlink(cli->tree, fname);
 
        io.openx.level = RAW_OPEN_OPENX;
@@ -313,7 +321,9 @@ static bool test_openx(struct smbcli_state *cli, struct torture_context *tctx)
                if (open_funcs[i].with_file) {
                        fnum = create_complex_file(cli, tctx, fname);
                        if (fnum == -1) {
-                               d_printf("Failed to create file %s - %s\n", fname, smbcli_errstr(cli->tree));
+                               torture_result(tctx, TORTURE_FAIL,
+                                       "Failed to create file %s - %s\n",
+                                       fname, smbcli_errstr(cli->tree));
                                ret = false;
                                goto done;
                        }
@@ -322,9 +332,13 @@ static bool test_openx(struct smbcli_state *cli, struct torture_context *tctx)
                io.openx.in.open_func = open_funcs[i].open_func;
                status = smb_raw_open(cli->tree, tctx, &io);
                if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
-                       printf("(%s) incorrect status %s should be %s (i=%d with_file=%d open_func=0x%x)\n", 
-                              __location__, nt_errstr(status), nt_errstr(open_funcs[i].correct_status),
-                              i, (int)open_funcs[i].with_file, (int)open_funcs[i].open_func);
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s) incorrect status %s should be %s "
+                               "(i=%d with_file=%d open_func=0x%x)\n",
+                               __location__, nt_errstr(status),
+                               nt_errstr(open_funcs[i].correct_status),
+                               i, (int)open_funcs[i].with_file,
+                               (int)open_funcs[i].open_func);
                        ret = false;
                }
                if (NT_STATUS_IS_OK(status)) {
@@ -424,8 +438,10 @@ static bool test_openx(struct smbcli_state *cli, struct torture_context *tctx)
        status = smb_raw_open(cli->tree, tctx, &io);
        CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
        if (timeval_elapsed(&tv) > 3.0) {
-               printf("(%s) Incorrect timing in openx with timeout - waited %.2f seconds\n",
-                      __location__, timeval_elapsed(&tv));
+               torture_result(tctx, TORTURE_FAIL,
+                       "(%s) Incorrect timing in openx with timeout "
+                       "- waited %.2f seconds\n",
+                       __location__, timeval_elapsed(&tv));
                ret = false;
        }
        smbcli_close(cli->tree, fnum);
@@ -527,13 +543,15 @@ static bool test_t2open(struct smbcli_state *cli, struct torture_context *tctx)
 
        fnum = create_complex_file(cli, tctx, fname1);
        if (fnum == -1) {
-               d_printf("Failed to create file %s - %s\n", fname1, smbcli_errstr(cli->tree));
+               torture_result(tctx, TORTURE_FAIL,
+                       "(%s): Failed to create file %s - %s\n",
+                       __location__, fname1, smbcli_errstr(cli->tree));
                ret = false;
                goto done;
        }
        smbcli_close(cli->tree, fnum);
 
-       printf("Checking RAW_OPEN_T2OPEN\n");
+       torture_comment(tctx, "Checking RAW_OPEN_T2OPEN\n");
 
        io.t2open.level = RAW_OPEN_T2OPEN;
        io.t2open.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
@@ -570,16 +588,21 @@ static bool test_t2open(struct smbcli_state *cli, struct torture_context *tctx)
                if ((io.t2open.in.num_eas != 0)
                    && NT_STATUS_EQUAL(status, NT_STATUS_EAS_NOT_SUPPORTED)
                    && torture_setting_bool(tctx, "samba3", false)) {
-                       printf("(%s) EAs not supported, not treating as fatal "
-                              "in Samba3 test\n", __location__);
+                       torture_warning(tctx, "(%s) EAs not supported, not "
+                               "treating as fatal in Samba3 test\n",
+                               __location__);
                        io.t2open.in.num_eas = 0;
                        goto again;
                }
 
                if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
-                       printf("(%s) incorrect status %s should be %s (i=%d with_file=%d open_func=0x%x)\n", 
-                              __location__, nt_errstr(status), nt_errstr(open_funcs[i].correct_status),
-                              i, (int)open_funcs[i].with_file, (int)open_funcs[i].open_func);
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s) incorrect status %s should be %s "
+                               "(i=%d with_file=%d open_func=0x%x)\n",
+                                __location__, nt_errstr(status),
+                               nt_errstr(open_funcs[i].correct_status),
+                               i, (int)open_funcs[i].with_file,
+                               (int)open_funcs[i].open_func);
                        ret = false;
                }
                if (NT_STATUS_IS_OK(status)) {
@@ -691,12 +714,12 @@ static bool test_ntcreatex(struct smbcli_state *cli, struct torture_context *tct
                { 6,                            false, NT_STATUS_INVALID_PARAMETER },
        };
 
-       printf("Checking RAW_OPEN_NTCREATEX\n");
+       torture_comment(tctx, "Checking RAW_OPEN_NTCREATEX\n");
 
        /* reasonable default parameters */
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 1024*1024;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -712,7 +735,9 @@ static bool test_ntcreatex(struct smbcli_state *cli, struct torture_context *tct
                if (open_funcs[i].with_file) {
                        fnum = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR|O_TRUNC, DENY_NONE);
                        if (fnum == -1) {
-                               d_printf("Failed to create file %s - %s\n", fname, smbcli_errstr(cli->tree));
+                               torture_result(tctx, TORTURE_FAIL,
+                                       "Failed to create file %s - %s\n",
+                                       fname, smbcli_errstr(cli->tree));
                                ret = false;
                                goto done;
                        }
@@ -721,9 +746,13 @@ static bool test_ntcreatex(struct smbcli_state *cli, struct torture_context *tct
                io.ntcreatex.in.open_disposition = open_funcs[i].open_disp;
                status = smb_raw_open(cli->tree, tctx, &io);
                if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
-                       printf("(%s) incorrect status %s should be %s (i=%d with_file=%d open_disp=%d)\n", 
-                              __location__, nt_errstr(status), nt_errstr(open_funcs[i].correct_status),
-                              i, (int)open_funcs[i].with_file, (int)open_funcs[i].open_disp);
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s) incorrect status %s should be %s "
+                               "(i=%d with_file=%d open_disp=%d)\n",
+                               __location__, nt_errstr(status),
+                               nt_errstr(open_funcs[i].correct_status),
+                               i, (int)open_funcs[i].with_file,
+                               (int)open_funcs[i].open_disp);
                        ret = false;
                }
                if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {
@@ -866,12 +895,12 @@ static bool test_nttrans_create(struct smbcli_state *cli, struct torture_context
                { 6,                            false, NT_STATUS_INVALID_PARAMETER },
        };
 
-       printf("Checking RAW_OPEN_NTTRANS_CREATE\n");
+       torture_comment(tctx, "Checking RAW_OPEN_NTTRANS_CREATE\n");
 
        /* reasonable default parameters */
        io.generic.level = RAW_OPEN_NTTRANS_CREATE;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 1024*1024;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -889,7 +918,9 @@ static bool test_nttrans_create(struct smbcli_state *cli, struct torture_context
                if (open_funcs[i].with_file) {
                        fnum = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR|O_TRUNC, DENY_NONE);
                        if (fnum == -1) {
-                               d_printf("Failed to create file %s - %s\n", fname, smbcli_errstr(cli->tree));
+                               torture_result(tctx, TORTURE_FAIL,
+                                       "Failed to create file %s - %s\n",
+                                       fname, smbcli_errstr(cli->tree));
                                ret = false;
                                goto done;
                        }
@@ -898,9 +929,13 @@ static bool test_nttrans_create(struct smbcli_state *cli, struct torture_context
                io.ntcreatex.in.open_disposition = open_funcs[i].open_disp;
                status = smb_raw_open(cli->tree, tctx, &io);
                if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
-                       printf("(%s) incorrect status %s should be %s (i=%d with_file=%d open_disp=%d)\n", 
-                              __location__, nt_errstr(status), nt_errstr(open_funcs[i].correct_status),
-                              i, (int)open_funcs[i].with_file, (int)open_funcs[i].open_disp);
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s) incorrect status %s should be %s "
+                               "(i=%d with_file=%d open_disp=%d)\n",
+                               __location__, nt_errstr(status),
+                               nt_errstr(open_funcs[i].correct_status),
+                               i, (int)open_funcs[i].with_file,
+                               (int)open_funcs[i].open_disp);
                        ret = false;
                }
                if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {
@@ -984,8 +1019,9 @@ static bool test_nttrans_create(struct smbcli_state *cli, struct torture_context
                io.ntcreatex.in.create_options = create_option;
                status = smb_raw_open(cli->tree, tctx, &io);
                if (!NT_STATUS_IS_OK(status)) {
-                       printf("ntcreatex create option 0x%08x gave %s - should give NT_STATUS_OK\n",
-                              create_option, nt_errstr(status));
+                       torture_warning(tctx, "ntcreatex create option 0x%08x "
+                               "gave %s - should give NT_STATUS_OK\n",
+                               create_option, nt_errstr(status));
                }
                CHECK_STATUS(status, NT_STATUS_OK);
                fnum = io.ntcreatex.out.file.fnum;
@@ -1032,7 +1068,8 @@ static bool test_nttrans_create(struct smbcli_state *cli, struct torture_context
                        not_a_directory_mask |= 1<<i;
                } else {
                        unexpected_mask |= 1<<i;
-                       printf("create option 0x%08x returned %s\n", create_option, nt_errstr(status));
+                       torture_comment(tctx, "create option 0x%08x returned %s\n",
+                                       create_option, nt_errstr(status));
                }
        }
 
@@ -1110,11 +1147,11 @@ static bool test_ntcreatex_brlocked(struct smbcli_state *cli, struct torture_con
        NTSTATUS status;
        bool ret = true;
 
-       printf("Testing ntcreatex with a byte range locked file\n");
+       torture_comment(tctx, "Testing ntcreatex with a byte range locked file\n");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = 0x2019f;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1145,7 +1182,7 @@ static bool test_ntcreatex_brlocked(struct smbcli_state *cli, struct torture_con
 
        io1.generic.level = RAW_OPEN_NTCREATEX;
        io1.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io1.ntcreatex.in.root_fid = 0;
+       io1.ntcreatex.in.root_fid.fnum = 0;
        io1.ntcreatex.in.access_mask = 0x20196;
        io1.ntcreatex.in.alloc_size = 0;
        io1.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1181,7 +1218,7 @@ static bool test_mknew(struct smbcli_state *cli, struct torture_context *tctx)
        time_t basetime = (time(NULL) + 3600*24*3) & ~1;
        union smb_fileinfo finfo;
 
-       printf("Checking RAW_OPEN_MKNEW\n");
+       torture_comment(tctx, "Checking RAW_OPEN_MKNEW\n");
 
        io.mknew.level = RAW_OPEN_MKNEW;
        io.mknew.in.attrib = 0;
@@ -1236,7 +1273,7 @@ static bool test_create(struct smbcli_state *cli, struct torture_context *tctx)
        time_t basetime = (time(NULL) + 3600*24*3) & ~1;
        union smb_fileinfo finfo;
 
-       printf("Checking RAW_OPEN_CREATE\n");
+       torture_comment(tctx, "Checking RAW_OPEN_CREATE\n");
 
        io.create.level = RAW_OPEN_CREATE;
        io.create.in.attrib = 0;
@@ -1292,7 +1329,7 @@ static bool test_ctemp(struct smbcli_state *cli, TALLOC_CTX *tctx)
        union smb_fileinfo finfo;
        const char *name, *fname = NULL;
 
-       printf("Checking RAW_OPEN_CTEMP\n");
+       torture_comment(tctx, "Checking RAW_OPEN_CTEMP\n");
 
        io.ctemp.level = RAW_OPEN_CTEMP;
        io.ctemp.in.attrib = FILE_ATTRIBUTE_HIDDEN;
@@ -1310,7 +1347,7 @@ static bool test_ctemp(struct smbcli_state *cli, TALLOC_CTX *tctx)
        CHECK_STATUS(status, NT_STATUS_OK);
 
        fname = finfo.name_info.out.fname.s;
-       d_printf("ctemp name=%s  real name=%s\n", name, fname);
+       torture_comment(tctx, "ctemp name=%s  real name=%s\n", name, fname);
 
 done:
        smbcli_close(cli->tree, fnum);
@@ -1335,7 +1372,7 @@ static bool test_chained(struct smbcli_state *cli, TALLOC_CTX *tctx)
        const char *buf = "test";
        char buf2[4];
 
-       printf("Checking RAW_OPEN_OPENX chained with READX\n");
+       torture_comment(tctx, "Checking RAW_OPEN_OPENX chained with READX\n");
        smbcli_unlink(cli->tree, fname);
 
        fnum = create_complex_file(cli, tctx, fname);
@@ -1366,7 +1403,8 @@ static bool test_chained(struct smbcli_state *cli, TALLOC_CTX *tctx)
        fnum = io.openxreadx.out.file.fnum;
 
        if (memcmp(buf, buf2, sizeof(buf)) != 0) {
-               d_printf("wrong data in reply buffer\n");
+               torture_result(tctx, TORTURE_FAIL,
+                       "wrong data in reply buffer\n");
                ret = false;
        }
 
@@ -1391,15 +1429,16 @@ static bool test_no_leading_slash(struct smbcli_state *cli, TALLOC_CTX *tctx)
        bool ret = true;
        const char *buf = "test";
 
-       printf("Checking RAW_OPEN_OPENX without leading slash on path\n");
+       torture_comment(tctx, "Checking RAW_OPEN_OPENX without leading "
+                       "slash on path\n");
        smbcli_unlink(cli->tree, fname);
 
-        /* Create the file */
+       /* Create the file */
        fnum = create_complex_file(cli, tctx, fname);
        smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
        smbcli_close(cli->tree, fnum);  
 
-        /* Prepare to open the file using path without leading slash */
+       /* Prepare to open the file using path without leading slash */
        io.openx.level = RAW_OPEN_OPENX;
        io.openx.in.fname = fname + 1;
        io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
@@ -1437,14 +1476,14 @@ static bool test_openx_over_dir(struct smbcli_state *cli, TALLOC_CTX *tctx)
        int fnum = -1;
        bool ret = true;
 
-       printf("Checking RAW_OPEN_OPENX over an existing directory\n");
+       torture_comment(tctx, "Checking RAW_OPEN_OPENX over an existing directory\n");
        smbcli_unlink(cli->tree, fname);
 
-        /* Create the Directory */
+       /* Create the Directory */
        status = create_directory_handle(cli->tree, fname, &d_fnum);
        smbcli_close(cli->tree, d_fnum);        
 
-        /* Prepare to open the file over the directory. */
+       /* Prepare to open the file over the directory. */
        io.openx.level = RAW_OPEN_OPENX;
        io.openx.in.fname = fname;
        io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
@@ -1492,7 +1531,8 @@ static bool test_raw_open_multi(struct torture_context *tctx)
        ios = talloc_array(mem_ctx, union smb_open, num_files);
        if ((tctx->ev == NULL) || (clients == NULL) || (requests == NULL) ||
            (ios == NULL)) {
-               DEBUG(0, ("talloc failed\n"));
+               torture_result(tctx, TORTURE_FAIL, "(%s): talloc failed\n",
+                               __location__);
                return false;
        }
 
@@ -1505,7 +1545,9 @@ static bool test_raw_open_multi(struct torture_context *tctx)
        for (i=0; i<num_files; i++) {
                if (!torture_open_connection_share(mem_ctx, &(clients[i]),
                                                   tctx, host, share, tctx->ev)) {
-                       DEBUG(0, ("Could not open %d'th connection\n", i));
+                       torture_result(tctx, TORTURE_FAIL,
+                                      "(%s): Could not open %d'th connection\n",
+                                      __location__, i);
                        return false;
                }
                clients[i]->tree->session->transport->options.request_timeout = 60;
@@ -1518,7 +1560,7 @@ static bool test_raw_open_multi(struct torture_context *tctx)
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1536,12 +1578,14 @@ static bool test_raw_open_multi(struct torture_context *tctx)
                ios[i] = io;
                requests[i] = smb_raw_open_send(clients[i]->tree, &ios[i]);
                if (requests[i] == NULL) {
-                       DEBUG(0, ("could not send %d'th request\n", i));
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s): could not send %d'th request\n",
+                               __location__, i);
                        return false;
                }
        }
 
-       DEBUG(10, ("waiting for replies\n"));
+       torture_comment(tctx, "waiting for replies\n");
        while (1) {
                bool unreplied = false;
                for (i=0; i<num_files; i++) {
@@ -1555,8 +1599,8 @@ static bool test_raw_open_multi(struct torture_context *tctx)
                        status = smb_raw_open_recv(requests[i], mem_ctx,
                                                   &ios[i]);
 
-                       DEBUG(0, ("File %d returned status %s\n", i,
-                                 nt_errstr(status)));
+                       torture_comment(tctx, "File %d returned status %s\n", i,
+                                 nt_errstr(status));
 
                        if (NT_STATUS_IS_OK(status)) {
                                num_ok += 1;
@@ -1574,7 +1618,8 @@ static bool test_raw_open_multi(struct torture_context *tctx)
                }
 
                if (event_loop_once(tctx->ev) != 0) {
-                       DEBUG(0, ("event_loop_once failed\n"));
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s): event_loop_once failed\n", __location__);
                        return false;
                }
        }
@@ -1602,12 +1647,12 @@ static bool test_open_for_delete(struct smbcli_state *cli, struct torture_contex
        int fnum = -1;
        bool ret = true;
 
-       printf("Checking RAW_NTCREATEX for delete on a readonly file.\n");
+       torture_comment(tctx, "Checking RAW_NTCREATEX for delete on a readonly file.\n");
 
        /* reasonable default parameters */
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_READONLY;
@@ -1647,8 +1692,175 @@ done:
        return ret;
 }
 
+/*
+  test chained RAW_OPEN_NTCREATEX_READX
+  Send chained NTCREATEX_READX on a file that doesn't exist, then create
+  the file and try again.
+*/
+static bool test_chained_ntcreatex_readx(struct smbcli_state *cli, struct torture_context *tctx)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       union smb_open io;
+       const char *fname = BASEDIR "\\torture_chained.txt";
+       NTSTATUS status;
+       int fnum = -1;
+       bool ret = true;
+       const char *buf = "test";
+       char buf2[4];
+
+       torture_comment(tctx, "Checking RAW_NTCREATEX_READX chained on "
+                             "non-existant file \n");
+       smbcli_unlink(cli->tree, fname);
+
+       /* ntcreatex parameters */
+       io.generic.level = RAW_OPEN_NTCREATEX_READX;
+       io.ntcreatexreadx.in.flags = 0;
+       io.ntcreatexreadx.in.root_fid.fnum = 0;
+       io.ntcreatexreadx.in.access_mask = SEC_FILE_READ_DATA;
+       io.ntcreatexreadx.in.alloc_size = 0;
+       io.ntcreatexreadx.in.file_attr = FILE_ATTRIBUTE_NORMAL;
+       io.ntcreatexreadx.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+               NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
+       io.ntcreatexreadx.in.open_disposition = NTCREATEX_DISP_OPEN;
+       io.ntcreatexreadx.in.create_options = 0;
+       io.ntcreatexreadx.in.impersonation = NTCREATEX_IMPERSONATION_IMPERSONATION;
+       io.ntcreatexreadx.in.security_flags = 0;
+       io.ntcreatexreadx.in.fname = fname;
+
+       /* readx parameters */
+       io.ntcreatexreadx.in.offset = 0;
+       io.ntcreatexreadx.in.mincnt = sizeof(buf);
+       io.ntcreatexreadx.in.maxcnt = sizeof(buf);
+       io.ntcreatexreadx.in.remaining = 0;
+       io.ntcreatexreadx.out.data = (uint8_t *)buf2;
+
+       /* try to open the non-existant file */
+       status = smb_raw_open(cli->tree, mem_ctx, &io);
+       CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
+       fnum = io.ntcreatexreadx.out.file.fnum;
+
+       smbcli_close(cli->tree, fnum);
+       smbcli_unlink(cli->tree, fname);
+
+       torture_comment(tctx, "Checking RAW_NTCREATEX_READX chained on "
+                             "existing file \n");
+
+       fnum = create_complex_file(cli, mem_ctx, fname);
+       smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
+       smbcli_close(cli->tree, fnum);
+
+       status = smb_raw_open(cli->tree, mem_ctx, &io);
+       CHECK_STATUS(status, NT_STATUS_OK);
+       fnum = io.ntcreatexreadx.out.file.fnum;
+
+       if (memcmp(buf, buf2, sizeof(buf)) != 0) {
+               torture_result(tctx, TORTURE_FAIL,
+                       "(%s): wrong data in reply buffer\n", __location__);
+               ret = false;
+       }
+
+done:
+       smbcli_close(cli->tree, fnum);
+       smbcli_unlink(cli->tree, fname);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+#define FILL_NTCREATEX(_struct, _init...)                       \
+       do {                                                    \
+               (_struct)->generic.level = RAW_OPEN_NTCREATEX;  \
+               (_struct)->ntcreatex.in                         \
+                   = (typeof((_struct)->ntcreatex.in)) {_init};\
+       } while (0)
+
+static bool test_ntcreatex_opendisp_dir(struct smbcli_state *cli,
+                                       struct torture_context *tctx)
+{
+       union smb_open io;
+       const char *dname = BASEDIR "\\torture_ntcreatex_opendisp_dir";
+       NTSTATUS status;
+       bool ret = true;
+       int i;
+       struct {
+               uint32_t open_disp;
+               bool dir_exists;
+               NTSTATUS correct_status;
+       } open_funcs_dir[] = {
+               { NTCREATEX_DISP_SUPERSEDE,     true,  NT_STATUS_INVALID_PARAMETER },
+               { NTCREATEX_DISP_SUPERSEDE,     false, NT_STATUS_INVALID_PARAMETER },
+               { NTCREATEX_DISP_OPEN,          true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN,          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
+               { NTCREATEX_DISP_CREATE,        true,  NT_STATUS_OBJECT_NAME_COLLISION },
+               { NTCREATEX_DISP_CREATE,        false, NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN_IF,       true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN_IF,       false, NT_STATUS_OK },
+               { NTCREATEX_DISP_OVERWRITE,     true,  NT_STATUS_INVALID_PARAMETER },
+               { NTCREATEX_DISP_OVERWRITE,     false, NT_STATUS_INVALID_PARAMETER },
+               { NTCREATEX_DISP_OVERWRITE_IF,  true,  NT_STATUS_INVALID_PARAMETER },
+               { NTCREATEX_DISP_OVERWRITE_IF,  false, NT_STATUS_INVALID_PARAMETER },
+               { 6,                            true,  NT_STATUS_INVALID_PARAMETER },
+               { 6,                            false, NT_STATUS_INVALID_PARAMETER },
+       };
+
+       if (!torture_setup_dir(cli, BASEDIR)) {
+               return false;
+       }
+
+       FILL_NTCREATEX(&io,
+           .flags = NTCREATEX_FLAGS_EXTENDED,
+           .access_mask = SEC_FLAG_MAXIMUM_ALLOWED,
+           .file_attr = FILE_ATTRIBUTE_DIRECTORY,
+           .share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE,
+           .create_options = NTCREATEX_OPTIONS_DIRECTORY,
+           .fname = dname,
+       );
+
+       smbcli_rmdir(cli->tree, dname);
+       smbcli_unlink(cli->tree, dname);
+
+       /* test the open disposition for directories */
+       torture_comment(tctx, "Testing open dispositions for directories...\n");
+
+       for (i=0; i<ARRAY_SIZE(open_funcs_dir); i++) {
+               if (open_funcs_dir[i].dir_exists) {
+                       status = smbcli_mkdir(cli->tree, dname);
+                       if (!NT_STATUS_IS_OK(status)) {
+                               torture_result(tctx, TORTURE_FAIL,
+                                       "(%s): Failed to make directory "
+                                       "%s - %s\n", __location__, dname,
+                                       smbcli_errstr(cli->tree));
+                               ret = false;
+                               goto done;
+                       }
+               }
+
+               io.ntcreatex.in.open_disposition = open_funcs_dir[i].open_disp;
+               status = smb_raw_open(cli->tree, tctx, &io);
+               if (!NT_STATUS_EQUAL(status, open_funcs_dir[i].correct_status)) {
+                       torture_result(tctx, TORTURE_FAIL,
+                               "(%s) incorrect status %s should be %s "
+                               "(i=%d dir_exists=%d open_disp=%d)\n",
+                               __location__, nt_errstr(status),
+                               nt_errstr(open_funcs_dir[i].correct_status),
+                               i, (int)open_funcs_dir[i].dir_exists,
+                               (int)open_funcs_dir[i].open_disp);
+                       ret = false;
+               }
+               if (NT_STATUS_IS_OK(status) || open_funcs_dir[i].dir_exists) {
+                       smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
+                       smbcli_rmdir(cli->tree, dname);
+               }
+       }
+
+done:
+       smbcli_rmdir(cli->tree, dname);
+       smbcli_deltree(cli->tree, BASEDIR);
+       return ret;
+}
+
 
-/* basic testing of all RAW_OPEN_* calls 
+/* basic testing of all RAW_OPEN_* calls
 */
 bool torture_raw_open(struct torture_context *torture, struct smbcli_state *cli)
 {
@@ -1669,9 +1881,11 @@ bool torture_raw_open(struct torture_context *torture, struct smbcli_state *cli)
        ret &= test_create(cli, torture);
        ret &= test_ctemp(cli, torture);
        ret &= test_chained(cli, torture);
+       ret &= test_chained_ntcreatex_readx(cli, torture);
        ret &= test_no_leading_slash(cli, torture);
        ret &= test_openx_over_dir(cli, torture);
        ret &= test_open_for_delete(cli, torture);
+       ret &= test_ntcreatex_opendisp_dir(cli, torture);
 
        smb_raw_exit(cli->session);
        smbcli_deltree(cli->tree, BASEDIR);

diff --git a/source4/torture/raw/openbench.c b/source4/torture/raw/openbench.c
index bdad2b16a5ea47d6f42b08b4b787a265c5e23e5d..2716f6a528507d0585d6ac913bd563e038e4663a 100644 (file)
--- a/source4/torture/raw/openbench.c
+++ b/source4/torture/raw/openbench.c
@@ -173,7 +173,7 @@ static void next_open(struct benchopen_state *state)
        DEBUG(2,("[%d] opening %u\n", state->client_num, state->pending_file_num));
        state->open_parms.ntcreatex.level = RAW_OPEN_NTCREATEX;
        state->open_parms.ntcreatex.in.flags = 0;
-       state->open_parms.ntcreatex.in.root_fid = 0;
+       state->open_parms.ntcreatex.in.root_fid.fnum = 0;
        state->open_parms.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        state->open_parms.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
        state->open_parms.ntcreatex.in.alloc_size = 0;

diff --git a/source4/torture/raw/oplock.c b/source4/torture/raw/oplock.c
index 1eaa7e214b4b9b78b89ee738ed8bc9fc2ce30d57..1b9d8e95c9262e95e9c1f9a83d91e5e41f6c8c3f 100644 (file)
--- a/source4/torture/raw/oplock.c
+++ b/source4/torture/raw/oplock.c
@@ -204,6 +204,60 @@ static bool open_connection_no_level2_oplocks(struct torture_context *tctx,
        return true;
 }
 
+/*
+   Timer handler function notifies the registering function that time is up
+*/
+static void timeout_cb(struct tevent_context *ev,
+                      struct tevent_timer *te,
+                      struct timeval current_time,
+                      void *private_data)
+{
+       bool *timesup = (bool *)private_data;
+       *timesup = true;
+       return;
+}
+
+/*
+   Wait a short period of time to receive a single oplock break request
+*/
+static void torture_wait_for_oplock_break(struct torture_context *tctx)
+{
+       TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+       struct tevent_timer *te = NULL;
+       struct timeval ne;
+       bool timesup = false;
+       int old_count = break_info.count;
+
+       /* Wait .1 seconds for an oplock break */
+       ne = tevent_timeval_current_ofs(0, 100000);
+
+       if ((te = event_add_timed(tctx->ev, tmp_ctx, ne, timeout_cb, &timesup))
+           == NULL)
+       {
+               torture_comment(tctx, "Failed to wait for an oplock break. "
+                                     "test results may not be accurate.");
+               goto done;
+       }
+
+       while (!timesup && break_info.count < old_count + 1) {
+               if (event_loop_once(tctx->ev) != 0) {
+                       torture_comment(tctx, "Failed to wait for an oplock "
+                                             "break. test results may not be "
+                                             "accurate.");
+                       goto done;
+               }
+       }
+
+done:
+       /* We don't know if the timed event fired and was freed, we received
+        * our oplock break, or some other event triggered the loop.  Thus,
+        * we create a tmp_ctx to be able to safely free/remove the timed
+        * event in all 3 cases. */
+       talloc_free(tmp_ctx);
+
+       return;
+}
+
 static bool test_raw_oplock_exclusive1(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 {
        const char *fname = BASEDIR "\\test_exclusive1.dat";
@@ -226,7 +280,7 @@ static bool test_raw_oplock_exclusive1(struct torture_context *tctx, struct smbc
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -249,6 +303,7 @@ static bool test_raw_oplock_exclusive1(struct torture_context *tctx, struct smbc
        torture_comment(tctx, "a 2nd open should not cause a break\n");
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -257,6 +312,7 @@ static bool test_raw_oplock_exclusive1(struct torture_context *tctx, struct smbc
        unl.unlink.in.attrib = 0;
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -291,7 +347,7 @@ static bool test_raw_oplock_exclusive2(struct torture_context *tctx, struct smbc
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -318,6 +374,7 @@ static bool test_raw_oplock_exclusive2(struct torture_context *tctx, struct smbc
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
@@ -331,6 +388,7 @@ static bool test_raw_oplock_exclusive2(struct torture_context *tctx, struct smbc
        unl.unlink.in.attrib = 0;
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -342,10 +400,11 @@ static bool test_raw_oplock_exclusive2(struct torture_context *tctx, struct smbc
        unl.unlink.in.attrib = 0;
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
-       torture_comment(tctx, "close 1st handle\n");
+       torture_comment(tctx, "close 2nd handle\n");
        smbcli_close(cli2->tree, fnum2);
 
        torture_comment(tctx, "unlink it\n");
@@ -353,6 +412,7 @@ static bool test_raw_oplock_exclusive2(struct torture_context *tctx, struct smbc
        unl.unlink.in.attrib = 0;
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -385,7 +445,7 @@ static bool test_raw_oplock_exclusive3(struct torture_context *tctx, struct smbc
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -415,6 +475,7 @@ static bool test_raw_oplock_exclusive3(struct torture_context *tctx, struct smbc
        status = smb_raw_setpathinfo(cli2->tree, &sfi);
 
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
@@ -449,7 +510,7 @@ static bool test_raw_oplock_exclusive4(struct torture_context *tctx, struct smbc
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -479,6 +540,7 @@ static bool test_raw_oplock_exclusive4(struct torture_context *tctx, struct smbc
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -514,7 +576,7 @@ static bool test_raw_oplock_exclusive5(struct torture_context *tctx, struct smbc
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -550,6 +612,7 @@ static bool test_raw_oplock_exclusive5(struct torture_context *tctx, struct smbc
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
 
@@ -587,7 +650,7 @@ static bool test_raw_oplock_exclusive6(struct torture_context *tctx, struct smbc
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -620,6 +683,7 @@ static bool test_raw_oplock_exclusive6(struct torture_context *tctx, struct smbc
        status = smb_raw_rename(cli2->tree, &rn);
 
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -655,7 +719,7 @@ static bool test_raw_oplock_batch1(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -685,6 +749,7 @@ static bool test_raw_oplock_batch1(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -695,13 +760,14 @@ static bool test_raw_oplock_batch1(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        torture_comment(tctx, "writing should generate a self break to none\n");
        smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
-       msleep(100);
-       smbcli_write(cli1->tree, fnum, 0, &c, 1, 1);
 
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
@@ -739,7 +805,7 @@ static bool test_raw_oplock_batch2(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -767,6 +833,7 @@ static bool test_raw_oplock_batch2(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -777,13 +844,13 @@ static bool test_raw_oplock_batch2(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        torture_comment(tctx, "writing should not generate a break\n");
        smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
-       msleep(100);
-       smbcli_write(cli1->tree, fnum, 0, &c, 1, 1);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        smbcli_close(cli1->tree, fnum);
@@ -817,7 +884,7 @@ static bool test_raw_oplock_batch3(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -845,6 +912,7 @@ static bool test_raw_oplock_batch3(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_unlink(cli2->tree, &unl);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, 1);
@@ -881,7 +949,7 @@ static bool test_raw_oplock_batch4(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -911,6 +979,7 @@ static bool test_raw_oplock_batch4(struct torture_context *tctx, struct smbcli_s
        rd.read.in.remaining = 0;
        status = smb_raw_read(cli1->tree, &rd);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -944,7 +1013,7 @@ static bool test_raw_oplock_batch5(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -973,6 +1042,7 @@ static bool test_raw_oplock_batch5(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, 1);
@@ -1004,12 +1074,13 @@ static bool test_raw_oplock_batch6(struct torture_context *tctx, struct smbcli_s
        smbcli_unlink(cli1->tree, fname);
 
        smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
+       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
 
        /*
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1022,8 +1093,6 @@ static bool test_raw_oplock_batch6(struct torture_context *tctx, struct smbcli_s
 
        torture_comment(tctx, "BATCH6: a 2nd open should give a break to level II if the first open allowed shared read\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
 
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
        io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
@@ -1042,6 +1111,7 @@ static bool test_raw_oplock_batch6(struct torture_context *tctx, struct smbcli_s
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
 
+       //torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, 1);
@@ -1050,8 +1120,10 @@ static bool test_raw_oplock_batch6(struct torture_context *tctx, struct smbcli_s
 
        torture_comment(tctx, "write should trigger a break to none on both\n");
        smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
-       msleep(100);
-       smbcli_write(cli1->tree, fnum, 0, &c, 1, 1);
+
+       /* We expect two breaks */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
 
        CHECK_VAL(break_info.count, 2);
        CHECK_VAL(break_info.level, 0);
@@ -1060,7 +1132,6 @@ static bool test_raw_oplock_batch6(struct torture_context *tctx, struct smbcli_s
        smbcli_close(cli1->tree, fnum);
        smbcli_close(cli2->tree, fnum2);
 
-
 done:
        smb_raw_exit(cli1->session);
        smb_raw_exit(cli2->session);
@@ -1089,7 +1160,7 @@ static bool test_raw_oplock_batch7(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1124,11 +1195,12 @@ static bool test_raw_oplock_batch7(struct torture_context *tctx, struct smbcli_s
        fnum = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum2);
        CHECK_VAL(break_info.level, 1);
        CHECK_VAL(break_info.failures, 0);
-       
+
        smbcli_close(cli2->tree, fnum);
 
 done:
@@ -1159,7 +1231,7 @@ static bool test_raw_oplock_batch8(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1193,6 +1265,7 @@ static bool test_raw_oplock_batch8(struct torture_context *tctx, struct smbcli_s
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -1228,7 +1301,7 @@ static bool test_raw_oplock_batch9(struct torture_context *tctx, struct smbcli_s
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1264,6 +1337,7 @@ static bool test_raw_oplock_batch9(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.failures, 0);
@@ -1283,6 +1357,7 @@ static bool test_raw_oplock_batch9(struct torture_context *tctx, struct smbcli_s
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
@@ -1292,11 +1367,9 @@ static bool test_raw_oplock_batch9(struct torture_context *tctx, struct smbcli_s
        torture_comment(tctx, "write should trigger a break to none on both\n");
        smbcli_write(cli2->tree, fnum2, 0, &c, 0, 1);
 
-       /* Now the oplock break request comes in. But right now we can't
-        * answer it. Do another write */
-
-       msleep(100);
-       smbcli_write(cli2->tree, fnum2, 0, &c, 1, 1);
+       /* We expect two breaks */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
 
        CHECK_VAL(break_info.count, 2);
        CHECK_VAL(break_info.level, 0);
@@ -1333,7 +1406,7 @@ static bool test_raw_oplock_batch10(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1354,6 +1427,7 @@ static bool test_raw_oplock_batch10(struct torture_context *tctx, struct smbcli_
        status = smb_raw_open(cli1->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
@@ -1371,6 +1445,7 @@ static bool test_raw_oplock_batch10(struct torture_context *tctx, struct smbcli_
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
@@ -1388,22 +1463,7 @@ static bool test_raw_oplock_batch10(struct torture_context *tctx, struct smbcli_
                CHECK_STATUS(tctx, status, NT_STATUS_OK);
        }
 
-       /* Now the oplock break request comes in. But right now we can't
-        * answer it. Do another write */
-
-       msleep(100);
-       
-       {
-               union smb_write wr;
-               wr.write.level = RAW_WRITE_WRITE;
-               wr.write.in.file.fnum = fnum;
-               wr.write.in.count = 1;
-               wr.write.in.offset = 0;
-               wr.write.in.remaining = 0;
-               wr.write.in.data = (const uint8_t *)"x";
-               status = smb_raw_write(cli1->tree, &wr);
-               CHECK_STATUS(tctx, status, NT_STATUS_OK);
-       }
+       torture_wait_for_oplock_break(tctx);
 
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum2);
@@ -1442,7 +1502,7 @@ static bool test_raw_oplock_batch11(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1457,10 +1517,9 @@ static bool test_raw_oplock_batch11(struct torture_context *tctx, struct smbcli_
        torture_comment(tctx, "BATCH11: Test if setpathinfo set EOF breaks oplocks.\n");
 
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
-               NTCREATEX_FLAGS_REQUEST_OPLOCK | 
+               NTCREATEX_FLAGS_REQUEST_OPLOCK |
                NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
@@ -1470,18 +1529,20 @@ static bool test_raw_oplock_batch11(struct torture_context *tctx, struct smbcli_
        status = smb_raw_open(cli1->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
-       
+
        ZERO_STRUCT(sfi);
        sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
        sfi.generic.in.file.path = fname;
        sfi.end_of_file_info.in.size = 100;
 
         status = smb_raw_setpathinfo(cli2->tree, &sfi);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, 0);
@@ -1517,7 +1578,7 @@ static bool test_raw_oplock_batch12(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1535,7 +1596,7 @@ static bool test_raw_oplock_batch12(struct torture_context *tctx, struct smbcli_
        smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
-               NTCREATEX_FLAGS_REQUEST_OPLOCK | 
+               NTCREATEX_FLAGS_REQUEST_OPLOCK |
                NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
@@ -1545,18 +1606,20 @@ static bool test_raw_oplock_batch12(struct torture_context *tctx, struct smbcli_
        status = smb_raw_open(cli1->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
-       
+
        ZERO_STRUCT(sfi);
        sfi.generic.level = SMB_SFILEINFO_ALLOCATION_INFORMATION;
        sfi.generic.in.file.path = fname;
        sfi.allocation_info.in.alloc_size = 65536 * 8;
 
         status = smb_raw_setpathinfo(cli2->tree, &sfi);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, 0);
@@ -1592,7 +1655,7 @@ static bool test_raw_oplock_batch13(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1605,8 +1668,6 @@ static bool test_raw_oplock_batch13(struct torture_context *tctx, struct smbcli_
 
        torture_comment(tctx, "BATCH13: open with batch oplock\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | 
                NTCREATEX_FLAGS_REQUEST_OPLOCK | 
@@ -1634,6 +1695,7 @@ static bool test_raw_oplock_batch13(struct torture_context *tctx, struct smbcli_
        status = smb_raw_open(cli2->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
@@ -1669,7 +1731,7 @@ static bool test_raw_oplock_batch14(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1682,7 +1744,6 @@ static bool test_raw_oplock_batch14(struct torture_context *tctx, struct smbcli_
 
        torture_comment(tctx, "BATCH14: open with batch oplock\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | 
                NTCREATEX_FLAGS_REQUEST_OPLOCK | 
@@ -1711,6 +1772,8 @@ static bool test_raw_oplock_batch14(struct torture_context *tctx, struct smbcli_
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
 
@@ -1745,7 +1808,7 @@ static bool test_raw_oplock_batch15(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1760,7 +1823,6 @@ static bool test_raw_oplock_batch15(struct torture_context *tctx, struct smbcli_
        torture_comment(tctx, "BATCH15: Test if qpathinfo all info breaks a batch oplock (should not).\n");
 
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
                NTCREATEX_FLAGS_REQUEST_OPLOCK |
@@ -1774,6 +1836,8 @@ static bool test_raw_oplock_batch15(struct torture_context *tctx, struct smbcli_
        status = smb_raw_open(cli1->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum = io.ntcreatex.out.file.fnum;
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
@@ -1783,8 +1847,9 @@ static bool test_raw_oplock_batch15(struct torture_context *tctx, struct smbcli_
        qfi.generic.in.file.path = fname;
 
        status = smb_raw_pathinfo(cli2->tree, tctx, &qfi);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        smbcli_close(cli1->tree, fnum);
@@ -1818,7 +1883,7 @@ static bool test_raw_oplock_batch16(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1831,8 +1896,6 @@ static bool test_raw_oplock_batch16(struct torture_context *tctx, struct smbcli_
 
        torture_comment(tctx, "BATCH16: open with batch oplock\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
                NTCREATEX_FLAGS_REQUEST_OPLOCK |
@@ -1861,6 +1924,8 @@ static bool test_raw_oplock_batch16(struct torture_context *tctx, struct smbcli_
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
 
@@ -1898,7 +1963,7 @@ static bool test_raw_oplock_batch17(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -1930,8 +1995,9 @@ static bool test_raw_oplock_batch17(struct torture_context *tctx, struct smbcli_
 
        torture_comment(tctx, "trying rename while first file open\n");
        status = smb_raw_rename(cli2->tree, &rn);
-
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -1969,7 +2035,7 @@ static bool test_raw_oplock_batch18(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2001,8 +2067,9 @@ static bool test_raw_oplock_batch18(struct torture_context *tctx, struct smbcli_
        rn.ntrename.in.new_name = fname2;
        torture_comment(tctx, "trying rename while first file open\n");
        status = smb_raw_rename(cli2->tree, &rn);
-
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -2043,7 +2110,7 @@ static bool test_raw_oplock_batch19(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2073,8 +2140,9 @@ static bool test_raw_oplock_batch19(struct torture_context *tctx, struct smbcli_
        sfi.rename_information.in.new_name      = fname2+strlen(BASEDIR)+1;
 
         status = smb_raw_setpathinfo(cli2->tree, &sfi);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        ZERO_STRUCT(qfi);
@@ -2095,6 +2163,8 @@ static bool test_raw_oplock_batch19(struct torture_context *tctx, struct smbcli_
 
        status = smb_raw_setfileinfo(cli1->tree, &sfi);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        ZERO_STRUCT(qfi);
@@ -2146,7 +2216,7 @@ bool test_trans2rename(struct torture_context *tctx, struct smbcli_state *cli1,
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2177,6 +2247,8 @@ bool test_trans2rename(struct torture_context *tctx, struct smbcli_state *cli1,
         status = smb_raw_setpathinfo(cli2->tree, &sfi);
 
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        ZERO_STRUCT(qfi);
@@ -2197,6 +2269,8 @@ bool test_trans2rename(struct torture_context *tctx, struct smbcli_state *cli1,
 
        status = smb_raw_setfileinfo(cli1->tree, &sfi);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        ZERO_STRUCT(qfi);
@@ -2246,7 +2320,7 @@ bool test_nttransrename(struct torture_context *tctx, struct smbcli_state *cli1)
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2274,8 +2348,9 @@ bool test_nttransrename(struct torture_context *tctx, struct smbcli_state *cli1)
        rn.nttrans.in.new_name  = fname2+strlen(BASEDIR)+1;
 
         status = smb_raw_rename(cli1->tree, &rn);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        /* w2k3 does nothing, it doesn't rename the file */
@@ -2367,7 +2442,7 @@ static bool test_raw_oplock_batch20(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2400,8 +2475,9 @@ static bool test_raw_oplock_batch20(struct torture_context *tctx, struct smbcli_
        sfi.rename_information.in.new_name      = fname2+strlen(BASEDIR)+1;
 
        status = smb_raw_setpathinfo(cli2->tree, &sfi);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        ZERO_STRUCT(qfi);
@@ -2425,6 +2501,8 @@ static bool test_raw_oplock_batch20(struct torture_context *tctx, struct smbcli_
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -2439,6 +2517,8 @@ static bool test_raw_oplock_batch20(struct torture_context *tctx, struct smbcli_
 
        status = smb_raw_setfileinfo(cli1->tree, &sfi);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.failures, 0);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -2492,7 +2572,7 @@ static bool test_raw_oplock_batch21(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2526,6 +2606,7 @@ static bool test_raw_oplock_batch21(struct torture_context *tctx, struct smbcli_
        status = smb_raw_echo(cli1->transport, &e);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        smbcli_close(cli1->tree, fnum);
@@ -2565,7 +2646,7 @@ static bool test_raw_oplock_batch22(struct torture_context *tctx, struct smbcli_
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2592,11 +2673,13 @@ static bool test_raw_oplock_batch22(struct torture_context *tctx, struct smbcli_
        fnum = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
 
-       torture_comment(tctx, "a 2nd open shoud not succeed after the oplock break timeout\n");
+       torture_comment(tctx, "a 2nd open should not succeed after the oplock "
+                       "break timeout\n");
        tv = timeval_current();
        smbcli_oplock_handler(cli1->transport, oplock_handler_timeout, cli1->tree);
        status = smb_raw_open(cli1->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
+       torture_wait_for_oplock_break(tctx);
        te = (int)timeval_elapsed(&tv);
        CHECK_RANGE(te, timeout - 1, timeout + 15);
 
@@ -2606,12 +2689,14 @@ static bool test_raw_oplock_batch22(struct torture_context *tctx, struct smbcli_
        CHECK_VAL(break_info.failures, 0);
        ZERO_STRUCT(break_info);
 
-       torture_comment(tctx, "a 2nd open shoud succeed after the oplock release without break\n");
+       torture_comment(tctx, "a 2nd open should succeed after the oplock "
+                       "release without break\n");
        tv = timeval_current();
        smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
        status = smb_raw_open(cli1->tree, tctx, &io);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
+       torture_wait_for_oplock_break(tctx);
        te = (int)timeval_elapsed(&tv);
        /* it should come in without delay */
        CHECK_RANGE(te+1, 0, timeout);
@@ -2645,16 +2730,18 @@ static bool test_raw_oplock_batch23(struct torture_context *tctx, struct smbcli_
        /* cleanup */
        smbcli_unlink(cli1->tree, fname);
 
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-
        ret = open_connection_no_level2_oplocks(tctx, &cli3);
        CHECK_VAL(ret, true);
 
+       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
+       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
+       smbcli_oplock_handler(cli3->transport, oplock_handler_ack_to_given, cli3->tree);
+
        /*
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2667,9 +2754,6 @@ static bool test_raw_oplock_batch23(struct torture_context *tctx, struct smbcli_
 
        torture_comment(tctx, "BATCH23: a open and ask for a batch oplock\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
-       smbcli_oplock_handler(cli3->transport, oplock_handler_ack_to_given, cli3->tree);
 
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
        io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
@@ -2689,6 +2773,7 @@ static bool test_raw_oplock_batch23(struct torture_context *tctx, struct smbcli_
        fnum3 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
@@ -2702,6 +2787,7 @@ static bool test_raw_oplock_batch23(struct torture_context *tctx, struct smbcli_
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        smbcli_close(cli1->tree, fnum);
@@ -2732,16 +2818,18 @@ static bool test_raw_oplock_batch24(struct torture_context *tctx, struct smbcli_
        /* cleanup */
        smbcli_unlink(cli1->tree, fname);
 
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-
        ret = open_connection_no_level2_oplocks(tctx, &cli3);
        CHECK_VAL(ret, true);
 
+       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
+       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
+       smbcli_oplock_handler(cli3->transport, oplock_handler_ack_to_given, cli3->tree);
+
        /*
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2754,9 +2842,6 @@ static bool test_raw_oplock_batch24(struct torture_context *tctx, struct smbcli_
 
        torture_comment(tctx, "BATCH24: a open without level support and ask for a batch oplock\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
-       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
-       smbcli_oplock_handler(cli3->transport, oplock_handler_ack_to_given, cli3->tree);
 
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
        io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
@@ -2776,6 +2861,7 @@ static bool test_raw_oplock_batch24(struct torture_context *tctx, struct smbcli_
        fnum2 = io.ntcreatex.out.file.fnum;
        CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.fnum, fnum3);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
@@ -2816,7 +2902,7 @@ static bool test_raw_oplock_batch25(struct torture_context *tctx,
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -2848,8 +2934,9 @@ static bool test_raw_oplock_batch25(struct torture_context *tctx,
        sfi.setattr.in.write_time       = 0;
 
         status = smb_raw_setpathinfo(cli2->tree, &sfi);
-
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
+
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
 
        smbcli_close(cli1->tree, fnum);
@@ -2880,25 +2967,25 @@ static bool test_raw_oplock_stream1(struct torture_context *tctx,
            NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK | NTCREATEX_FLAGS_EXTENDED;
        uint32_t exclusive_req = NTCREATEX_FLAGS_REQUEST_OPLOCK |
            NTCREATEX_FLAGS_EXTENDED;
-       /* Try some permutations of taking oplocks on streams. */
+
 #define NSTREAM_OPLOCK_RESULTS 8
        struct {
-               const char *fname;
+               const char **fname;
                bool open_base_file;
                uint32_t oplock_req;
                uint32_t oplock_granted;
        } stream_oplock_results[NSTREAM_OPLOCK_RESULTS] = {
                /* Request oplock on stream without the base file open. */
-               {fname_stream, false, batch_req, NO_OPLOCK_RETURN},
-               {fname_default_stream, false, batch_req, NO_OPLOCK_RETURN},
-               {fname_stream, false, exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
-               {fname_default_stream, false,  exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
+               {&fname_stream, false, batch_req, NO_OPLOCK_RETURN},
+               {&fname_default_stream, false, batch_req, NO_OPLOCK_RETURN},
+               {&fname_stream, false, exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
+               {&fname_default_stream, false,  exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
 
                /* Request oplock on stream with the base file open. */
-               {fname_stream, true, batch_req, NO_OPLOCK_RETURN},
-               {fname_default_stream, true, batch_req, NO_OPLOCK_RETURN},
-               {fname_stream, true, exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
-               {fname_default_stream, true,  exclusive_req, LEVEL_II_OPLOCK_RETURN},
+               {&fname_stream, true, batch_req, NO_OPLOCK_RETURN},
+               {&fname_default_stream, true, batch_req, NO_OPLOCK_RETURN},
+               {&fname_stream, true, exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
+               {&fname_default_stream, true,  exclusive_req, LEVEL_II_OPLOCK_RETURN},
 
        };
 
@@ -2918,12 +3005,12 @@ static bool test_raw_oplock_stream1(struct torture_context *tctx,
        }
        smbcli_unlink(cli1->tree, fname_base);
 
-       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
        smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
+       smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
 
        /* Setup generic open parameters. */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
            SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
        io.ntcreatex.in.create_options = 0;
@@ -2945,8 +3032,9 @@ static bool test_raw_oplock_stream1(struct torture_context *tctx,
        /* Change the disposition to open now that the file has been created. */
        io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
 
+       /* Try some permutations of taking oplocks on streams. */
        for (i = 0; i < NSTREAM_OPLOCK_RESULTS; i++) {
-               const char *fname = stream_oplock_results[i].fname;
+               const char *fname = *stream_oplock_results[i].fname;
                bool open_base_file = stream_oplock_results[i].open_base_file;
                uint32_t oplock_req = stream_oplock_results[i].oplock_req;
                uint32_t oplock_granted =
@@ -2955,7 +3043,7 @@ static bool test_raw_oplock_stream1(struct torture_context *tctx,
 
                if (open_base_file) {
                        torture_comment(tctx, "Opening base file: %s with "
-                           "%d\n", fname_base, oplock_req);
+                           "%d\n", fname_base, batch_req);
                        io.ntcreatex.in.fname = fname_base;
                        io.ntcreatex.in.flags = batch_req;
                        status = smb_raw_open(cli2->tree, tctx, &io);
@@ -3004,6 +3092,7 @@ static bool test_raw_oplock_stream1(struct torture_context *tctx,
            BATCH_OPLOCK_RETURN);
        smbcli_close(cli2->tree, io.ntcreatex.out.file.fnum);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.failures, 0);
 
@@ -3019,6 +3108,7 @@ static bool test_raw_oplock_stream1(struct torture_context *tctx,
            LEVEL_II_OPLOCK_RETURN);
        smbcli_close(cli2->tree, io.ntcreatex.out.file.fnum);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
        CHECK_VAL(break_info.failures, 0);
@@ -3059,7 +3149,7 @@ static bool test_raw_oplock_doc(struct torture_context *tctx,
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -3122,7 +3212,7 @@ static bool test_raw_oplock_brl1(struct torture_context *tctx,
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
                                      SEC_RIGHTS_FILE_WRITE;
        io.ntcreatex.in.alloc_size = 0;
@@ -3160,8 +3250,6 @@ static bool test_raw_oplock_brl1(struct torture_context *tctx,
 
        torture_comment(tctx, "a 2nd open should give a break\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
-                             cli1->tree);
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
        status = smb_raw_open(cli2->tree, tctx, &io);
@@ -3173,19 +3261,13 @@ static bool test_raw_oplock_brl1(struct torture_context *tctx,
        CHECK_VAL(break_info.fnum, fnum);
 
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
-                             cli1->tree);
 
-       torture_comment(tctx, "attempt BRL test\n");
+       torture_comment(tctx, "a self BRL acquisition should break to none\n");
 
        status = smbcli_lock(cli1->tree, fnum, 0, 4, 0, WRITE_LOCK);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
 
-       /*
-        * Even though level 2 oplock breaks are asynchronous, with self
-        * contention we'll always break the oplock before the contending
-        * operation's response is sent.
-        */
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
        CHECK_VAL(break_info.fnum, fnum);
@@ -3196,6 +3278,7 @@ static bool test_raw_oplock_brl1(struct torture_context *tctx,
        status = smbcli_lock(cli1->tree, fnum, 2, 4, 0, WRITE_LOCK);
        CHECK_STATUS(tctx, status, NT_STATUS_LOCK_NOT_GRANTED);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.level, 0);
        CHECK_VAL(break_info.fnum, 0);
@@ -3240,7 +3323,7 @@ static bool test_raw_oplock_brl2(struct torture_context *tctx, struct smbcli_sta
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
                                      SEC_RIGHTS_FILE_WRITE;
        io.ntcreatex.in.alloc_size = 0;
@@ -3278,10 +3361,8 @@ static bool test_raw_oplock_brl2(struct torture_context *tctx, struct smbcli_sta
                goto done;
        }
 
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
-                             cli1->tree);
-
-       torture_comment(tctx, "attempt BRL test\n");
+       torture_comment(tctx, "a self BRL acquisition should not break to "
+                       "none\n");
 
        status = smbcli_lock(cli1->tree, fnum, 0, 4, 0, WRITE_LOCK);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
@@ -3292,6 +3373,7 @@ static bool test_raw_oplock_brl2(struct torture_context *tctx, struct smbcli_sta
        /* With one file handle open a BRL should not contend our oplock.
         * Thus, no oplock break will be received and the entire break_info
         * struct will be 0 */
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.fnum, 0);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.level, 0);
@@ -3334,7 +3416,7 @@ static bool test_raw_oplock_brl3(struct torture_context *tctx,
          base ntcreatex parms
        */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
                                      SEC_RIGHTS_FILE_WRITE;
        io.ntcreatex.in.alloc_size = 0;
@@ -3373,8 +3455,6 @@ static bool test_raw_oplock_brl3(struct torture_context *tctx,
 
        torture_comment(tctx, "a 2nd open should give a break\n");
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
-                             cli1->tree);
 
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
        status = smb_raw_open(cli1->tree, tctx, &io);
@@ -3386,19 +3466,13 @@ static bool test_raw_oplock_brl3(struct torture_context *tctx,
        CHECK_VAL(break_info.fnum, fnum);
 
        ZERO_STRUCT(break_info);
-       smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
-                             cli1->tree);
 
-       torture_comment(tctx, "attempt BRL test\n");
+       torture_comment(tctx, "a self BRL acquisition should break to none\n");
 
        status = smbcli_lock(cli1->tree, fnum, 0, 4, 0, WRITE_LOCK);
        CHECK_STATUS(tctx, status, NT_STATUS_OK);
 
-       /*
-        * Even though level 2 oplock breaks are asynchrounous, with self
-        * contention we'll always break the oplock before the contending
-        * operation's response is sent.
-        */
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 1);
        CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
        CHECK_VAL(break_info.fnum, fnum);
@@ -3409,6 +3483,7 @@ static bool test_raw_oplock_brl3(struct torture_context *tctx,
        status = smbcli_lock(cli1->tree, fnum, 2, 4, 0, WRITE_LOCK);
        CHECK_STATUS(tctx, status, NT_STATUS_LOCK_NOT_GRANTED);
 
+       torture_wait_for_oplock_break(tctx);
        CHECK_VAL(break_info.count, 0);
        CHECK_VAL(break_info.level, 0);
        CHECK_VAL(break_info.fnum, 0);
@@ -3421,7 +3496,6 @@ done:
        smb_raw_exit(cli1->session);
        smbcli_deltree(cli1->tree, BASEDIR);
        return ret;
-
 }
 
 /*
@@ -3503,7 +3577,7 @@ bool torture_bench_oplock(struct torture_context *torture)
        }
 
        io.ntcreatex.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -3629,7 +3703,7 @@ bool torture_hold_oplock(struct torture_context *torture,
                char c = 1;
 
                io.generic.level = RAW_OPEN_NTCREATEX;
-               io.ntcreatex.in.root_fid = 0;
+               io.ntcreatex.in.root_fid.fnum = 0;
                io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
                io.ntcreatex.in.alloc_size = 0;
                io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;

diff --git a/source4/torture/raw/read.c b/source4/torture/raw/read.c
index f99da8fb1ee2ed9b3b1be179d9b2761e770c5456..ea1fc125a792508cd12d022a4f580593796c8c95 100644 (file)
--- a/source4/torture/raw/read.c
+++ b/source4/torture/raw/read.c
@@ -815,7 +815,7 @@ static bool test_read_for_execute(struct torture_context *tctx,
        printf("Testing RAW_READ_READX with read_for_execute\n");
 
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        op.ntcreatex.in.create_options = 0;
@@ -846,7 +846,7 @@ static bool test_read_for_execute(struct torture_context *tctx,
 
        printf("open file with SEC_FILE_EXECUTE\n");
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_FILE_EXECUTE;
        op.ntcreatex.in.create_options = 0;
@@ -893,7 +893,7 @@ static bool test_read_for_execute(struct torture_context *tctx,
 
        printf("open file with SEC_FILE_READ_DATA\n");
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_FILE_READ_DATA;
        op.ntcreatex.in.create_options = 0;

diff --git a/source4/torture/raw/rename.c b/source4/torture/raw/rename.c
index 15fed0e3d8f6b6ddbf50c753d196fb8940fbaff3..cf04769764f854695338266fb055bb5480415f6b 100644 (file)
--- a/source4/torture/raw/rename.c
+++ b/source4/torture/raw/rename.c
@@ -67,7 +67,7 @@ static bool test_mv(struct torture_context *tctx,
        torture_comment(tctx, "Trying simple rename\n");
 
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        op.ntcreatex.in.create_options = 0;
@@ -208,7 +208,7 @@ static bool test_osxrename(struct torture_context *tctx,
                return false;
        }
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
        op.ntcreatex.in.create_options = 0;
@@ -528,8 +528,9 @@ static bool test_dir_rename(struct torture_context *tctx, struct smbcli_state *c
        NTSTATUS status;
         const char *dname1 = BASEDIR "\\dir_for_rename";
         const char *dname2 = BASEDIR "\\renamed_dir";
+        const char *dname1_long = BASEDIR "\\dir_for_rename_long";
         const char *fname = BASEDIR "\\dir_for_rename\\file.txt";
-       const char *sname = BASEDIR "\\dir_for_rename:a stream:$DATA";
+       const char *sname = BASEDIR "\\renamed_dir:a stream:$DATA";
        bool ret = true;
        int fnum = -1;
 
@@ -542,8 +543,10 @@ static bool test_dir_rename(struct torture_context *tctx, struct smbcli_state *c
         /* create a directory */
         smbcli_rmdir(cli->tree, dname1);
         smbcli_rmdir(cli->tree, dname2);
+        smbcli_rmdir(cli->tree, dname1_long);
         smbcli_unlink(cli->tree, dname1);
         smbcli_unlink(cli->tree, dname2);
+        smbcli_unlink(cli->tree, dname1_long);
 
         ZERO_STRUCT(io);
         io.generic.level = RAW_OPEN_NTCREATEX;
@@ -561,12 +564,20 @@ static bool test_dir_rename(struct torture_context *tctx, struct smbcli_state *c
         fnum = io.ntcreatex.out.file.fnum;
        smbcli_close(cli->tree, fnum);
 
+        /* create the longname directory */
+        io.ntcreatex.in.fname = dname1_long;
+        status = smb_raw_open(cli->tree, tctx, &io);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        fnum = io.ntcreatex.out.file.fnum;
+       smbcli_close(cli->tree, fnum);
+
         /* Now create and hold open a file. */
         ZERO_STRUCT(io);
 
         io.generic.level = RAW_OPEN_NTCREATEX;
         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-        io.ntcreatex.in.root_fid = 0;
+        io.ntcreatex.in.root_fid.fnum = 0;
         io.ntcreatex.in.alloc_size = 0;
         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -625,6 +636,31 @@ static bool test_dir_rename(struct torture_context *tctx, struct smbcli_state *c
        /* close our handle to the directory. */
        smbcli_close(cli->tree, fnum);
 
+       /* Open a handle on the long name, and then
+        * try a rename. This would catch a regression
+        * in bug #6781.
+        */
+       io.ntcreatex.in.fname = dname1_long;
+       io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
+
+       io.ntcreatex.in.access_mask = SEC_STD_READ_CONTROL |
+           SEC_FILE_READ_ATTRIBUTE | SEC_FILE_READ_EA | SEC_FILE_READ_DATA;
+
+       status = smb_raw_open(cli->tree, tctx, &io);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        fnum = io.ntcreatex.out.file.fnum;
+
+       ren_io.generic.level = RAW_RENAME_RENAME;
+       ren_io.rename.in.pattern1 = dname1;
+       ren_io.rename.in.pattern2 = dname2;
+       ren_io.rename.in.attrib = 0;
+
+       status = smb_raw_rename(cli->tree, &ren_io);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       /* close our handle to the longname directory. */
+       smbcli_close(cli->tree, fnum);
+
        /*
         * Now try opening a stream on the directory and holding it open
         * across a rename.  This should be allowed.
@@ -636,15 +672,15 @@ static bool test_dir_rename(struct torture_context *tctx, struct smbcli_state *c
         fnum = io.ntcreatex.out.file.fnum;
 
        ren_io.generic.level = RAW_RENAME_RENAME;
-       ren_io.rename.in.pattern1 = dname1;
-       ren_io.rename.in.pattern2 = dname2;
+       ren_io.rename.in.pattern1 = dname2;
+       ren_io.rename.in.pattern2 = dname1;
        ren_io.rename.in.attrib = 0;
 
        status = smb_raw_rename(cli->tree, &ren_io);
        CHECK_STATUS(status, NT_STATUS_OK);
 
 done:
-       
+
        if (fnum != -1) {
                smbcli_close(cli->tree, fnum);
        }

diff --git a/source4/torture/raw/samba3misc.c b/source4/torture/raw/samba3misc.c
index 6d6eabce2d75b0f67f534fc6f37b329543e0e59c..e8dc12fd40293a7f6f030f6dd57d8ea49fd839fc 100644 (file)
--- a/source4/torture/raw/samba3misc.c
+++ b/source4/torture/raw/samba3misc.c
@@ -90,7 +90,7 @@ bool torture_samba3_checkfsp(struct torture_context *torture)
                union smb_open io;
                io.generic.level = RAW_OPEN_NTCREATEX;
                io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-               io.ntcreatex.in.root_fid = 0;
+               io.ntcreatex.in.root_fid.fnum = 0;
                io.ntcreatex.in.security_flags = 0;
                io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
                io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
@@ -304,7 +304,7 @@ static NTSTATUS raw_smbcli_ntcreate(struct smbcli_tree *tree, const char *fname,
        memset(&io, '\0', sizeof(io));
         io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.alloc_size = 0;
        io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
@@ -887,7 +887,7 @@ bool torture_samba3_rootdirfid(struct torture_context *tctx)
        ZERO_STRUCT(io);
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.security_flags = 0;
        io.ntcreatex.in.access_mask =
                SEC_STD_SYNCHRONIZE | SEC_FILE_EXECUTE;
@@ -912,7 +912,7 @@ bool torture_samba3_rootdirfid(struct torture_context *tctx)
        io.ntcreatex.in.flags =
                NTCREATEX_FLAGS_REQUEST_OPLOCK
                | NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
-       io.ntcreatex.in.root_fid = dnum;
+       io.ntcreatex.in.root_fid.fnum = dnum;
        io.ntcreatex.in.security_flags = 0;
        io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
@@ -961,7 +961,7 @@ bool torture_samba3_oplock_logoff(struct torture_context *tctx)
        ZERO_STRUCT(io);
        io.generic.level = RAW_OPEN_NTCREATEX;
        io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.security_flags = 0;
        io.ntcreatex.in.access_mask =
                SEC_STD_SYNCHRONIZE | SEC_FILE_EXECUTE;

diff --git a/source4/torture/raw/streams.c b/source4/torture/raw/streams.c
index 6c5dc85a10580f7a1c4f1488b5cc0e633140d548..5c6bd63157cb491ea94935d6d1a8409ca221b4f1 100644 (file)
--- a/source4/torture/raw/streams.c
+++ b/source4/torture/raw/streams.c
@@ -221,7 +221,7 @@ static bool test_stream_dir(struct torture_context *tctx,
 
        printf("(%s) opening non-existant directory stream\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -237,7 +237,7 @@ static bool test_stream_dir(struct torture_context *tctx,
 
        printf("(%s) opening basedir  stream\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -253,7 +253,7 @@ static bool test_stream_dir(struct torture_context *tctx,
 
        printf("(%s) opening basedir ::$DATA stream\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0x10;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = 0;
@@ -297,7 +297,7 @@ static bool test_stream_io(struct torture_context *tctx,
 
        printf("(%s) creating a stream on a non-existant file\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = 0;
@@ -434,7 +434,7 @@ static bool test_stream_sharemodes(struct torture_context *tctx,
 
        printf("(%s) testing stream share mode conflicts\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = 0;
@@ -523,7 +523,7 @@ static bool test_stream_delete(struct torture_context *tctx,
 
        printf("(%s) opening non-existant file stream\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = 0;
@@ -698,7 +698,7 @@ static bool test_stream_names(struct torture_context *tctx,
 
        printf("(%s) testing stream names\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = 0;
@@ -966,7 +966,7 @@ static bool test_stream_names2(struct torture_context *tctx,
 
        printf("(%s) testing stream names\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
        io.ntcreatex.in.create_options = 0;
@@ -1060,7 +1060,7 @@ static bool test_stream_rename(struct torture_context *tctx,
 
        printf("(%s) testing stream renames\n", __location__);
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE |
                                      SEC_FILE_WRITE_ATTRIBUTE |
@@ -1135,7 +1135,7 @@ static bool test_stream_rename2(struct torture_context *tctx,
        sname2 = talloc_asprintf(mem_ctx, "%s:%s", fname1, "Stream Two");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
            SEC_STD_DELETE|SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
@@ -1318,7 +1318,7 @@ static bool create_file_with_stream(struct torture_context *tctx,
 
        /* Create a file with a stream */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
            SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
@@ -1365,7 +1365,7 @@ static bool test_stream_create_disposition(struct torture_context *tctx,
 
        /* Open the base file with OPEN */
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
            SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
@@ -1573,7 +1573,7 @@ static bool test_stream_attributes(struct torture_context *tctx,
        /* Now open the stream name. */
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
            SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL|SEC_FILE_WRITE_ATTRIBUTE);

diff --git a/source4/torture/raw/tconrate.c b/source4/torture/raw/tconrate.c
index 076e5be31ff4150c6cfe93af508afbe8c1ae6ba2..06cb7650c154711e44b138bb8f949a0fff31a164 100644 (file)
--- a/source4/torture/raw/tconrate.c
+++ b/source4/torture/raw/tconrate.c
@@ -112,6 +112,7 @@ static int fork_tcon_client(struct torture_context *tctx,
                }
 
                smbcli_tdis(cli);
+               talloc_free(cli);
 
                *tcon_count = *tcon_count + 1;
                now = timeval_current();

diff --git a/source4/torture/raw/unlink.c b/source4/torture/raw/unlink.c
index a9f635b637b56eba4e58d403e14ec1e7dbf0eaf1..28218b26fddc0880b06040c6935f12884ed5a14b 100644 (file)
--- a/source4/torture/raw/unlink.c
+++ b/source4/torture/raw/unlink.c
@@ -327,7 +327,7 @@ static bool test_delete_on_close(struct torture_context *tctx,
        smbcli_close(cli->tree, fnum2);
 
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        op.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY |NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
@@ -359,7 +359,7 @@ static bool test_delete_on_close(struct torture_context *tctx,
        smbcli_close(cli->tree, fnum2);
 
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        op.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY |NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
@@ -394,7 +394,7 @@ static bool test_delete_on_close(struct torture_context *tctx,
        /* we have a dir with a file in it, no handles open */
 
        op.generic.level = RAW_OPEN_NTCREATEX;
-       op.ntcreatex.in.root_fid = 0;
+       op.ntcreatex.in.root_fid.fnum = 0;
        op.ntcreatex.in.flags = 0;
        op.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        op.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY |NTCREATEX_OPTIONS_DELETE_ON_CLOSE;

diff --git a/source4/torture/rpc/drsuapi.c b/source4/torture/rpc/drsuapi.c
index 174de5e98163721fcacf53be254d3b36e959f63a..8f6bbb163b6198f7de22794a97c8815076dc7e77 100644 (file)
--- a/source4/torture/rpc/drsuapi.c
+++ b/source4/torture/rpc/drsuapi.c
@@ -35,11 +35,46 @@ bool test_DsBind(struct dcerpc_pipe *p,
 {
        NTSTATUS status;
        struct drsuapi_DsBind r;
+       struct drsuapi_DsBindInfo28 *bind_info28;
+       struct drsuapi_DsBindInfoCtr bind_info_ctr;
+
+       ZERO_STRUCT(bind_info_ctr);
+       bind_info_ctr.length = 28;
+
+       bind_info28 = &bind_info_ctr.info.info28;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
+       bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
 
        GUID_from_string(DRSUAPI_DS_BIND_GUID, &priv->bind_guid);
 
        r.in.bind_guid = &priv->bind_guid;
-       r.in.bind_info = NULL;
+       r.in.bind_info = &bind_info_ctr;
        r.out.bind_handle = &priv->bind_handle;
 
        torture_comment(tctx, "testing DsBind\n");
@@ -47,6 +82,9 @@ bool test_DsBind(struct dcerpc_pipe *p,
        status = dcerpc_drsuapi_DsBind(p, tctx, &r);
        torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsBind");
 
+       /* cache server supported extensions, i.e. bind_info */
+       priv->srv_bind_info = r.out.bind_info->info.info28;
+
        return true;
 }
 
@@ -416,51 +454,64 @@ static bool test_DsReplicaUpdateRefs(struct torture_context *tctx,
 {
        NTSTATUS status;
        struct dcerpc_pipe *p = priv->pipe;
-       int i;
        struct drsuapi_DsReplicaUpdateRefs r;
        struct drsuapi_DsReplicaObjectIdentifier nc;
        struct GUID null_guid;
+       struct GUID dest_dsa_guid;
+       const char *dest_dsa_guid_str;
        struct dom_sid null_sid;
-       struct {
-               int32_t level;
-       } array[] = {
-               {       
-                       1
-               }
-       };
-
-       if (torture_setting_bool(tctx, "samba4", false)) {
-               torture_comment(tctx, "skipping DsReplicaUpdateRefs test against Samba4\n");
-               return true;
-       }
 
        ZERO_STRUCT(null_guid);
        ZERO_STRUCT(null_sid);
+       dest_dsa_guid = GUID_random();
+       dest_dsa_guid_str = GUID_string(tctx, &dest_dsa_guid);
 
-       r.in.bind_handle        = &priv->bind_handle;
-
-       for (i=0; i < ARRAY_SIZE(array); i++) {
-               torture_comment(tctx, "testing DsReplicaUpdateRefs level %d\n",
-                               array[i].level);
-
-               r.in.level = array[i].level;
-               switch(r.in.level) {
-               case 1:
-                       nc.guid                         = null_guid;
-                       nc.sid                          = null_sid;
-                       nc.dn                           = priv->domain_obj_dn ? priv->domain_obj_dn : "";
-
-                       r.in.req.req1.naming_context    = &nc;
-                       r.in.req.req1.dest_dsa_dns_name = talloc_asprintf(tctx, "__some_dest_dsa_guid_string._msdn.%s",
-                                                                               priv->domain_dns_name);
-                       r.in.req.req1.dest_dsa_guid     = null_guid;
-                       r.in.req.req1.options           = 0;
-                       break;
-               }
-
-               status = dcerpc_drsuapi_DsReplicaUpdateRefs(p, tctx, &r);
-               torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsReplicaUpdateRefs");
-       }
+       r.in.bind_handle = &priv->bind_handle;
+       r.in.level       = 1; /* Only version 1 is defined presently */
+
+       /* setup NC */
+       nc.guid         = priv->domain_obj_dn ? null_guid : priv->domain_guid;
+       nc.sid          = null_sid;
+       nc.dn           = priv->domain_obj_dn ? priv->domain_obj_dn : "";
+
+       /* default setup for request */
+       r.in.req.req1.naming_context    = &nc;
+       r.in.req.req1.dest_dsa_dns_name = talloc_asprintf(tctx, "%s._msdn.%s",
+                                                               dest_dsa_guid_str,
+                                                               priv->domain_dns_name);
+       r.in.req.req1.dest_dsa_guid     = dest_dsa_guid;
+
+       /* 1. deleting replica dest should fail */
+       torture_comment(tctx, "delete: %s\n", r.in.req.req1.dest_dsa_dns_name);
+       r.in.req.req1.options           = DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE;
+       status = dcerpc_drsuapi_DsReplicaUpdateRefs(p, tctx, &r);
+       torture_drsuapi_assert_call_werr(tctx, p,
+                                        status, WERR_DS_DRA_REF_NOT_FOUND, &r,
+                                        "dcerpc_drsuapi_DsReplicaUpdateRefs");
+
+       /* 2. hopefully adding random replica dest should succeed */
+       torture_comment(tctx, "add   : %s\n", r.in.req.req1.dest_dsa_dns_name);
+       r.in.req.req1.options           = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE;
+       status = dcerpc_drsuapi_DsReplicaUpdateRefs(p, tctx, &r);
+       torture_drsuapi_assert_call_werr(tctx, p,
+                                        status, WERR_OK, &r,
+                                        "dcerpc_drsuapi_DsReplicaUpdateRefs");
+
+       /* 3. try adding same replica dest - should fail */
+       torture_comment(tctx, "add   : %s\n", r.in.req.req1.dest_dsa_dns_name);
+       r.in.req.req1.options           = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE;
+       status = dcerpc_drsuapi_DsReplicaUpdateRefs(p, tctx, &r);
+       torture_drsuapi_assert_call_werr(tctx, p,
+                                        status, WERR_DS_DRA_REF_ALREADY_EXISTS, &r,
+                                        "dcerpc_drsuapi_DsReplicaUpdateRefs");
+
+       /* 4. delete random replicate added at step 2. */
+       torture_comment(tctx, "delete: %s\n", r.in.req.req1.dest_dsa_dns_name);
+       r.in.req.req1.options           = DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE;
+       status = dcerpc_drsuapi_DsReplicaUpdateRefs(p, tctx, &r);
+       torture_drsuapi_assert_call_werr(tctx, p,
+                                        status, WERR_OK, &r,
+                                        "dcerpc_drsuapi_DsReplicaUpdateRefs");
 
        return true;
 }

diff --git a/source4/torture/rpc/drsuapi.h b/source4/torture/rpc/drsuapi.h
index d32a35ee2c3596d786859339c4deb15ac84620a6..a10ea5068e60b091212f058097c8210f0631a710 100644 (file)
--- a/source4/torture/rpc/drsuapi.h
+++ b/source4/torture/rpc/drsuapi.h
@@ -30,6 +30,8 @@ struct DsPrivate {
        struct dcerpc_pipe *pipe;
        struct policy_handle bind_handle;
        struct GUID bind_guid;
+       struct drsuapi_DsBindInfo28 srv_bind_info;
+
        const char *domain_obj_dn;
        const char *domain_guid_str;
        const char *domain_dns_name;
@@ -45,10 +47,11 @@ struct DsPrivate {
  * \param _tctx torture context
  * \param _p DCERPC pipe handle
  * \param _ntstatus NTSTATUS for dcerpc_drsuapi_ call
- * \param _pr in/out DCEPRC request structure
+ * \param _werr_expected Expected windows error to be returned
+ * \param _pr in/out DCEPRC request structure - pointer
  * \param _msg error message prefix
  */
-#define torture_drsuapi_assert_call(_tctx, _p, _ntstat, _pr, _msg) \
+#define torture_drsuapi_assert_call_werr(_tctx, _p, _ntstat, _werr_expected, _pr, _msg) \
        do { \
                NTSTATUS __nt = _ntstat; \
                if (!NT_STATUS_IS_OK(__nt)) { \
@@ -58,6 +61,18 @@ struct DsPrivate {
                        } \
                        torture_fail(tctx, talloc_asprintf(_tctx, "%s failed - %s", _msg, errstr)); \
                } \
-               torture_assert_werr_ok(_tctx, (_pr)->out.result, _msg); \
+               torture_assert_werr_equal(_tctx, (_pr)->out.result, _werr_expected, _msg); \
        } while(0)
 
+/**
+ * Custom torture macro to check dcerpc_drsuapi_ call
+ * return values printing more friendly messages
+ * \param _tctx torture context
+ * \param _p DCERPC pipe handle
+ * \param _ntstatus NTSTATUS for dcerpc_drsuapi_ call
+ * \param _pr in/out DCEPRC request structure
+ * \param _msg error message prefix
+ */
+#define torture_drsuapi_assert_call(_tctx, _p, _ntstat, _pr, _msg) \
+       torture_drsuapi_assert_call_werr(_tctx, _p, _ntstat, WERR_OK, _pr, _msg)
+

diff --git a/source4/torture/rpc/dssync.c b/source4/torture/rpc/dssync.c
index b47564cc91dc09bd8afc09c2ffaea709a41eb06d..a9341d569b47da259c489366adaeda3ccd3d4083 100644 (file)
--- a/source4/torture/rpc/dssync.c
+++ b/source4/torture/rpc/dssync.c
@@ -36,6 +36,9 @@
 #include "auth/gensec/gensec.h"
 #include "param/param.h"
 #include "dsdb/samdb/samdb.h"
+#include "torture/rpc/rpc.h"
+#include "torture/drs/proto.h"
+
 
 struct DsSyncBindInfo {
        struct dcerpc_pipe *pipe;
@@ -489,6 +492,98 @@ static void test_analyse_objects(struct torture_context *tctx,
        }
 }
 
+/**
+ * Fetch LDAP attribute name and DN by supplied OID
+ */
+static bool _drs_ldap_attr_by_oid(struct torture_context *tctx,
+                                       struct DsSyncTest *ctx,
+                                       const char *oid,
+                                       const char **attr_dn,
+                                       const char **attr_name)
+{
+       NTSTATUS status;
+       const char *config_dn;
+       const char *expression;
+       struct ldap_message **res_msg;
+       struct ldap_SearchResEntry *search_res;
+       TALLOC_CTX *tmp_ctx = NULL;
+       const char *search_attrs[] = {"lDAPDisplayName", NULL};
+
+       tmp_ctx = talloc_new(ctx);
+
+       config_dn = talloc_asprintf(tmp_ctx, "CN=Schema,CN=Configuration,%s", ctx->domain_dn);
+       expression = talloc_asprintf(tmp_ctx, "(attributeID=%s)", oid);
+
+       status = ildap_search(ctx->admin.ldap.conn,
+                               config_dn, LDAP_SEARCH_SCOPE_SUB,
+                               expression, search_attrs, false,
+                               NULL, NULL, &res_msg);
+       torture_assert_ntstatus_ok(tctx, status, "LDAP search request failed");
+       torture_assert(tctx,
+                       ildap_count_entries(ctx->admin.ldap.conn, res_msg) == 1,
+                       talloc_asprintf(tmp_ctx, "Failed to find attribute with OID=%s", oid));
+
+       search_res = &res_msg[0]->r.SearchResultEntry;
+       torture_assert(tctx, search_res->num_attributes > 0, "No attributes returned!")
+       torture_assert(tctx, strequal(search_attrs[0], search_res->attributes[0].name),
+                       "Requested attributes for attribute class not returned");
+
+       if (attr_dn) {
+               *attr_dn = search_res->dn;
+       }
+
+       if (attr_name) {
+               *attr_name = (const char *)search_res->attributes[0].values[0].data;
+       }
+
+       talloc_free(tmp_ctx);
+
+       return true;
+}
+
+/**
+ * Make Attribute OID and verify such Attribute exists in schema
+ */
+static bool _drs_util_verify_attids(struct torture_context *tctx,
+                                   struct DsSyncTest *ctx,
+                                   struct drsuapi_DsReplicaOIDMapping_Ctr *prefix_map,
+                                   struct drsuapi_DsReplicaObjectListItemEx *cur)
+{
+       uint32_t i;
+
+       DEBUG(1,("drs_test_verify_attids:\n"));
+
+       for (; cur; cur = cur->next_object) {
+               const char *attr_dn = NULL;
+               const char *attr_name = NULL;
+               struct drsuapi_DsReplicaObject *obj = &cur->object;
+
+               DEBUG(1,("%3s %-10s: %s\n", "", "object_dn", obj->identifier->dn));
+
+               for (i = 0; i < obj->attribute_ctr.num_attributes; i++) {
+                       int map_idx;
+                       const char *oid = NULL;
+                       struct drsuapi_DsReplicaAttribute *attr;
+
+                       attr = &obj->attribute_ctr.attributes[i];
+                       if (!drs_util_oid_from_attid(tctx, prefix_map, attr->attid, &oid, &map_idx)) {
+                               return false;
+                       }
+
+                       if (!_drs_ldap_attr_by_oid(tctx, ctx, oid, &attr_dn, &attr_name)) {
+                               return false;
+                       }
+
+                       DEBUG(1,("%7s attr[%2d]: %-22s {map_idx=%2d; attid=0x%06x; ldap_name=%-26s; idl_name=%s}\n", "",
+                                       i, oid, map_idx, attr->attid, attr_name,
+                                       drs_util_DsAttributeId_to_string(attr->attid)));
+               }
+       }
+
+       return true;
+}
+
+
 static bool test_FetchData(struct torture_context *tctx, struct DsSyncTest *ctx)
 {
        NTSTATUS status;
@@ -670,6 +765,8 @@ static bool test_FetchData(struct torture_context *tctx, struct DsSyncTest *ctx)
                                        (long long)ctr1->new_highwatermark.tmp_highest_usn,
                                        (long long)ctr1->new_highwatermark.highest_usn));
 
+                               _drs_util_verify_attids(tctx, ctx, &ctr1->mapping_ctr, ctr1->first_object);
+
                                test_analyse_objects(tctx, ctx, &gensec_skey, ctr1->first_object);
 
                                if (ctr1->more_data) {
@@ -700,6 +797,8 @@ static bool test_FetchData(struct torture_context *tctx, struct DsSyncTest *ctx)
                                        (long long)ctr6->new_highwatermark.tmp_highest_usn,
                                        (long long)ctr6->new_highwatermark.highest_usn));
 
+                               _drs_util_verify_attids(tctx, ctx, &ctr6->mapping_ctr, ctr6->first_object);
+
                                test_analyse_objects(tctx, ctx, &gensec_skey, ctr6->first_object);
 
                                if (ctr6->more_data) {

diff --git a/source4/torture/rpc/frsapi.c b/source4/torture/rpc/frsapi.c
index e9a19bcf96d21a85f2d1cff15649583d8c540e25..24d769a3107569d8ed21e8dc2052178a81592e4f 100644 (file)
--- a/source4/torture/rpc/frsapi.c
+++ b/source4/torture/rpc/frsapi.c
@@ -193,8 +193,7 @@ static bool test_ForceReplication(struct torture_context *tctx,
 
        r.in.replica_set_guid = NULL;
        r.in.connection_guid = NULL;
-       r.in.replica_set_name = talloc_asprintf(tctx, "%s",
-                                               lp_realm(tctx->lp_ctx));
+       r.in.replica_set_name = lp_dnsdomain(tctx->lp_ctx);
        r.in.partner_dns_name = dcerpc_server_name(p);
 
        torture_assert_ntstatus_ok(tctx,

diff --git a/source4/torture/rpc/lsa_lookup.c b/source4/torture/rpc/lsa_lookup.c
index 0a4c9904d7e6d9671a0565a0e04e5fb8915dd10e..b1a348ce8af4fef061d272d9cde28fb3852b2704 100644 (file)
--- a/source4/torture/rpc/lsa_lookup.c
+++ b/source4/torture/rpc/lsa_lookup.c
@@ -227,8 +227,8 @@ bool torture_rpc_lsa_lookup(struct torture_context *torture)
         struct dcerpc_pipe *p;
        bool ret = true;
        struct policy_handle *handle;
-       struct dom_sid *dom_sid;
-       struct dom_sid *trusted_sid;
+       struct dom_sid *dom_sid = NULL;
+       struct dom_sid *trusted_sid = NULL;
        struct dom_sid *sids[NUM_SIDS];
 
        status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);

diff --git a/source4/torture/rpc/netlogon.c b/source4/torture/rpc/netlogon.c
index 35f1a5942f78f5710f8da168ce23a53a9f36cae2..f57c47b115404eb8297f52dd735a373bf8eb3122 100644 (file)
--- a/source4/torture/rpc/netlogon.c
+++ b/source4/torture/rpc/netlogon.c
@@ -1567,6 +1567,49 @@ static bool test_GetDcName(struct torture_context *tctx,
        return true;
 }
 
+static const char *function_code_str(TALLOC_CTX *mem_ctx,
+                                    enum netr_LogonControlCode function_code)
+{
+       switch (function_code) {
+       case NETLOGON_CONTROL_QUERY:
+               return "NETLOGON_CONTROL_QUERY";
+       case NETLOGON_CONTROL_REPLICATE:
+               return "NETLOGON_CONTROL_REPLICATE";
+       case NETLOGON_CONTROL_SYNCHRONIZE:
+               return "NETLOGON_CONTROL_SYNCHRONIZE";
+       case NETLOGON_CONTROL_PDC_REPLICATE:
+               return "NETLOGON_CONTROL_PDC_REPLICATE";
+       case NETLOGON_CONTROL_REDISCOVER:
+               return "NETLOGON_CONTROL_REDISCOVER";
+       case NETLOGON_CONTROL_TC_QUERY:
+               return "NETLOGON_CONTROL_TC_QUERY";
+       case NETLOGON_CONTROL_TRANSPORT_NOTIFY:
+               return "NETLOGON_CONTROL_TRANSPORT_NOTIFY";
+       case NETLOGON_CONTROL_FIND_USER:
+               return "NETLOGON_CONTROL_FIND_USER";
+       case NETLOGON_CONTROL_CHANGE_PASSWORD:
+               return "NETLOGON_CONTROL_CHANGE_PASSWORD";
+       case NETLOGON_CONTROL_TC_VERIFY:
+               return "NETLOGON_CONTROL_TC_VERIFY";
+       case NETLOGON_CONTROL_FORCE_DNS_REG:
+               return "NETLOGON_CONTROL_FORCE_DNS_REG";
+       case NETLOGON_CONTROL_QUERY_DNS_REG:
+               return "NETLOGON_CONTROL_QUERY_DNS_REG";
+       case NETLOGON_CONTROL_BACKUP_CHANGE_LOG:
+               return "NETLOGON_CONTROL_BACKUP_CHANGE_LOG";
+       case NETLOGON_CONTROL_TRUNCATE_LOG:
+               return "NETLOGON_CONTROL_TRUNCATE_LOG";
+       case NETLOGON_CONTROL_SET_DBFLAG:
+               return "NETLOGON_CONTROL_SET_DBFLAG";
+       case NETLOGON_CONTROL_BREAKPOINT:
+               return "NETLOGON_CONTROL_BREAKPOINT";
+       default:
+               return talloc_asprintf(mem_ctx, "unknown function code: %d",
+                                      function_code);
+       }
+}
+
+
 /*
   try a netlogon LogonControl 
 */
@@ -1576,19 +1619,82 @@ static bool test_LogonControl(struct torture_context *tctx,
        NTSTATUS status;
        struct netr_LogonControl r;
        union netr_CONTROL_QUERY_INFORMATION query;
-       int i;
+       int i,f;
+       uint32_t function_codes[] = {
+               NETLOGON_CONTROL_QUERY,
+               NETLOGON_CONTROL_REPLICATE,
+               NETLOGON_CONTROL_SYNCHRONIZE,
+               NETLOGON_CONTROL_PDC_REPLICATE,
+               NETLOGON_CONTROL_REDISCOVER,
+               NETLOGON_CONTROL_TC_QUERY,
+               NETLOGON_CONTROL_TRANSPORT_NOTIFY,
+               NETLOGON_CONTROL_FIND_USER,
+               NETLOGON_CONTROL_CHANGE_PASSWORD,
+               NETLOGON_CONTROL_TC_VERIFY,
+               NETLOGON_CONTROL_FORCE_DNS_REG,
+               NETLOGON_CONTROL_QUERY_DNS_REG,
+               NETLOGON_CONTROL_BACKUP_CHANGE_LOG,
+               NETLOGON_CONTROL_TRUNCATE_LOG,
+               NETLOGON_CONTROL_SET_DBFLAG,
+               NETLOGON_CONTROL_BREAKPOINT
+       };
 
        r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
        r.in.function_code = 1;
        r.out.query = &query;
 
-       for (i=1;i<4;i++) {
+       for (f=0;f<ARRAY_SIZE(function_codes); f++) {
+       for (i=1;i<5;i++) {
+
+               r.in.function_code = function_codes[f];
                r.in.level = i;
 
-               torture_comment(tctx, "Testing LogonControl level %d\n", i);
+               torture_comment(tctx, "Testing LogonControl function code %s (%d) level %d\n",
+                               function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
 
                status = dcerpc_netr_LogonControl(p, tctx, &r);
                torture_assert_ntstatus_ok(tctx, status, "LogonControl");
+
+               switch (r.in.level) {
+               case 1:
+                       switch (r.in.function_code) {
+                       case NETLOGON_CONTROL_REPLICATE:
+                       case NETLOGON_CONTROL_SYNCHRONIZE:
+                       case NETLOGON_CONTROL_PDC_REPLICATE:
+                       case NETLOGON_CONTROL_BACKUP_CHANGE_LOG:
+                       case NETLOGON_CONTROL_TRUNCATE_LOG:
+                       case NETLOGON_CONTROL_BREAKPOINT:
+                               torture_assert_werr_equal(tctx, r.out.result, WERR_ACCESS_DENIED,
+                                       "LogonControl returned unexpected error code");
+                               break;
+                       case NETLOGON_CONTROL_REDISCOVER:
+                       case NETLOGON_CONTROL_TC_QUERY:
+                       case NETLOGON_CONTROL_TRANSPORT_NOTIFY:
+                       case NETLOGON_CONTROL_FIND_USER:
+                       case NETLOGON_CONTROL_CHANGE_PASSWORD:
+                       case NETLOGON_CONTROL_TC_VERIFY:
+                       case NETLOGON_CONTROL_FORCE_DNS_REG:
+                       case NETLOGON_CONTROL_QUERY_DNS_REG:
+                       case NETLOGON_CONTROL_SET_DBFLAG:
+                               torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
+                                       "LogonControl returned unexpected error code");
+                               break;
+                       default:
+                               torture_assert_werr_ok(tctx, r.out.result,
+                                       "LogonControl returned unexpected result");
+                               break;
+                       }
+                       break;
+               case 2:
+                       torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
+                               "LogonControl returned unexpected error code");
+                       break;
+               default:
+                       torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
+                               "LogonControl returned unexpected error code");
+                       break;
+               }
+       }
        }
 
        return true;
@@ -1991,7 +2097,7 @@ static bool test_netr_DsRGetDCName(struct torture_context *tctx,
        struct netr_DsRGetDCNameInfo *info = NULL;
 
        r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
-       r.in.domain_name        = talloc_asprintf(tctx, "%s", lp_realm(tctx->lp_ctx));
+       r.in.domain_name        = lp_dnsdomain(tctx->lp_ctx);
        r.in.domain_guid        = NULL;
        r.in.site_guid          = NULL;
        r.in.flags              = DS_RETURN_DNS_NAME;
@@ -2016,7 +2122,7 @@ static bool test_netr_DsRGetDCNameEx(struct torture_context *tctx,
        struct netr_DsRGetDCNameInfo *info = NULL;
 
        r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
-       r.in.domain_name        = talloc_asprintf(tctx, "%s", lp_realm(tctx->lp_ctx));
+       r.in.domain_name        = lp_dnsdomain(tctx->lp_ctx);
        r.in.domain_guid        = NULL;
        r.in.site_name          = NULL;
        r.in.flags              = DS_RETURN_DNS_NAME;
@@ -2043,7 +2149,7 @@ static bool test_netr_DsRGetDCNameEx2(struct torture_context *tctx,
        r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
        r.in.client_account     = NULL;
        r.in.mask               = 0x00000000;
-       r.in.domain_name        = talloc_asprintf(tctx, "%s", lp_realm(tctx->lp_ctx));
+       r.in.domain_name        = lp_dnsdomain(tctx->lp_ctx);
        r.in.domain_guid        = NULL;
        r.in.site_name          = NULL;
        r.in.flags              = DS_RETURN_DNS_NAME;

diff --git a/source4/torture/rpc/samba3rpc.c b/source4/torture/rpc/samba3rpc.c
index 65d251013be352bb25a4bd74b06b6326c6a09509..4a529d38f628f5ec7048e75d77665d5a7ae719ff 100644 (file)
--- a/source4/torture/rpc/samba3rpc.c
+++ b/source4/torture/rpc/samba3rpc.c
@@ -2616,7 +2616,7 @@ static NTSTATUS find_printers(TALLOC_CTX *ctx, struct loadparm_context *lp_ctx,
        return NT_STATUS_OK;
 }
 
-static bool enumprinters(TALLOC_CTX *mem_ctx, struct dcerpc_pipe *pipe,
+static bool enumprinters(TALLOC_CTX *mem_ctx, struct dcerpc_pipe *p,
                         const char *servername, int level, int *num_printers)
 {
        struct spoolss_EnumPrinters r;
@@ -2635,7 +2635,7 @@ static bool enumprinters(TALLOC_CTX *mem_ctx, struct dcerpc_pipe *pipe,
        r.out.count = &count;
        r.out.info = &info;
 
-       status = dcerpc_spoolss_EnumPrinters(pipe, mem_ctx, &r);
+       status = dcerpc_spoolss_EnumPrinters(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                d_printf("(%s) dcerpc_spoolss_EnumPrinters failed: %s\n",
                         __location__, nt_errstr(status));
@@ -2658,7 +2658,7 @@ static bool enumprinters(TALLOC_CTX *mem_ctx, struct dcerpc_pipe *pipe,
        r.in.buffer = &blob;
        r.in.offered = needed;
 
-       status = dcerpc_spoolss_EnumPrinters(pipe, mem_ctx, &r);
+       status = dcerpc_spoolss_EnumPrinters(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
                d_printf("(%s) dcerpc_spoolss_EnumPrinters failed: %s, "
                         "%s\n", __location__, nt_errstr(status),
@@ -2671,7 +2671,7 @@ static bool enumprinters(TALLOC_CTX *mem_ctx, struct dcerpc_pipe *pipe,
        return true;
 }
 
-static NTSTATUS getprinterinfo(TALLOC_CTX *ctx, struct dcerpc_pipe *pipe,
+static NTSTATUS getprinterinfo(TALLOC_CTX *ctx, struct dcerpc_pipe *p,
                               struct policy_handle *handle, int level,
                               union spoolss_PrinterInfo **res)
 {
@@ -2692,7 +2692,7 @@ static NTSTATUS getprinterinfo(TALLOC_CTX *ctx, struct dcerpc_pipe *pipe,
        r.in.offered = 0;
        r.out.needed = &needed;
 
-       status = dcerpc_spoolss_GetPrinter(pipe, mem_ctx, &r);
+       status = dcerpc_spoolss_GetPrinter(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                d_printf("(%s) dcerpc_spoolss_GetPrinter failed: %s\n",
                         __location__, nt_errstr(status));
@@ -2719,7 +2719,7 @@ static NTSTATUS getprinterinfo(TALLOC_CTX *ctx, struct dcerpc_pipe *pipe,
        r.in.buffer = &blob;
        r.in.offered = needed;
 
-       status = dcerpc_spoolss_GetPrinter(pipe, mem_ctx, &r);
+       status = dcerpc_spoolss_GetPrinter(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
                d_printf("(%s) dcerpc_spoolss_GetPrinter failed: %s, "
                         "%s\n", __location__, nt_errstr(status),

diff --git a/source4/torture/rpc/samlogon.c b/source4/torture/rpc/samlogon.c
index 831893098960e0f85f8d9d00d0c1ca9d1f6dda7f..8e6c88425ce9e15886053b5bba0be3056f42658f 100644 (file)
--- a/source4/torture/rpc/samlogon.c
+++ b/source4/torture/rpc/samlogon.c
@@ -29,7 +29,7 @@
 #include "../lib/crypto/crypto.h"
 #include "lib/cmdline/popt_common.h"
 #include "torture/rpc/rpc.h"
-#include "auth/gensec/schannel_proto.h"
+#include "../libcli/auth/schannel.h"
 #include "auth/gensec/gensec.h"
 #include "libcli/auth/libcli_auth.h"
 #include "param/param.h"

diff --git a/source4/torture/rpc/samr.c b/source4/torture/rpc/samr.c
index f8853c1093b5defd469c1a5450ce69b8e089c19b..c448b3bb83ecbfe45b25e965e8f0f1f35dc2758c 100644 (file)
--- a/source4/torture/rpc/samr.c
+++ b/source4/torture/rpc/samr.c
@@ -2132,7 +2132,7 @@ bool test_ChangePasswordUser3(struct dcerpc_pipe *p, struct torture_context *tct
        uint8_t old_lm_hash[16], new_lm_hash[16];
        NTTIME t;
        struct samr_DomInfo1 *dominfo = NULL;
-       struct samr_ChangeReject *reject = NULL;
+       struct userPwdChangeFailureInformation *reject = NULL;
 
        torture_comment(tctx, "Testing ChangePasswordUser3\n");
 
@@ -2269,9 +2269,9 @@ bool test_ChangePasswordUser3(struct dcerpc_pipe *p, struct torture_context *tct
            && (!null_nttime(last_password_change) || !dominfo->min_password_age)) {
                if (dominfo->password_properties & DOMAIN_REFUSE_PASSWORD_CHANGE ) {
 
-                       if (reject && (reject->reason != SAMR_REJECT_OTHER)) {
-                               torture_warning(tctx, "expected SAMR_REJECT_OTHER (%d), got %d\n",
-                                       SAMR_REJECT_OTHER, reject->reason);
+                       if (reject && (reject->extendedFailureReason != SAM_PWD_CHANGE_NO_ERROR)) {
+                               torture_warning(tctx, "expected SAM_PWD_CHANGE_NO_ERROR (%d), got %d\n",
+                                       SAM_PWD_CHANGE_NO_ERROR, reject->extendedFailureReason);
                                return false;
                        }
                }
@@ -2288,40 +2288,40 @@ bool test_ChangePasswordUser3(struct dcerpc_pipe *p, struct torture_context *tct
                if ((dominfo->min_password_age > 0) && !null_nttime(last_password_change) &&
                           (last_password_change + dominfo->min_password_age > t)) {
 
-                       if (reject->reason != SAMR_REJECT_OTHER) {
-                               torture_warning(tctx, "expected SAMR_REJECT_OTHER (%d), got %d\n",
-                                       SAMR_REJECT_OTHER, reject->reason);
+                       if (reject->extendedFailureReason != SAM_PWD_CHANGE_NO_ERROR) {
+                               torture_warning(tctx, "expected SAM_PWD_CHANGE_NO_ERROR (%d), got %d\n",
+                                       SAM_PWD_CHANGE_NO_ERROR, reject->extendedFailureReason);
                                return false;
                        }
 
                } else if ((dominfo->min_password_length > 0) &&
                           (strlen(newpass) < dominfo->min_password_length)) {
 
-                       if (reject->reason != SAMR_REJECT_TOO_SHORT) {
-                               torture_warning(tctx, "expected SAMR_REJECT_TOO_SHORT (%d), got %d\n",
-                                       SAMR_REJECT_TOO_SHORT, reject->reason);
+                       if (reject->extendedFailureReason != SAM_PWD_CHANGE_PASSWORD_TOO_SHORT) {
+                               torture_warning(tctx, "expected SAM_PWD_CHANGE_PASSWORD_TOO_SHORT (%d), got %d\n",
+                                       SAM_PWD_CHANGE_PASSWORD_TOO_SHORT, reject->extendedFailureReason);
                                return false;
                        }
 
                } else if ((dominfo->password_history_length > 0) &&
                            strequal(oldpass, newpass)) {
 
-                       if (reject->reason != SAMR_REJECT_IN_HISTORY) {
-                               torture_warning(tctx, "expected SAMR_REJECT_IN_HISTORY (%d), got %d\n",
-                                       SAMR_REJECT_IN_HISTORY, reject->reason);
+                       if (reject->extendedFailureReason != SAM_PWD_CHANGE_PWD_IN_HISTORY) {
+                               torture_warning(tctx, "expected SAM_PWD_CHANGE_PWD_IN_HISTORY (%d), got %d\n",
+                                       SAM_PWD_CHANGE_PWD_IN_HISTORY, reject->extendedFailureReason);
                                return false;
                        }
                } else if (dominfo->password_properties & DOMAIN_PASSWORD_COMPLEX) {
 
-                       if (reject->reason != SAMR_REJECT_COMPLEXITY) {
-                               torture_warning(tctx, "expected SAMR_REJECT_COMPLEXITY (%d), got %d\n",
-                                       SAMR_REJECT_COMPLEXITY, reject->reason);
+                       if (reject->extendedFailureReason != SAM_PWD_CHANGE_NOT_COMPLEX) {
+                               torture_warning(tctx, "expected SAM_PWD_CHANGE_NOT_COMPLEX (%d), got %d\n",
+                                       SAM_PWD_CHANGE_NOT_COMPLEX, reject->extendedFailureReason);
                                return false;
                        }
 
                }
 
-               if (reject->reason == SAMR_REJECT_TOO_SHORT) {
+               if (reject->extendedFailureReason == SAM_PWD_CHANGE_PASSWORD_TOO_SHORT) {
                        /* retry with adjusted size */
                        return test_ChangePasswordUser3(p, tctx, account_string,
                                                        dominfo->min_password_length,
@@ -2330,9 +2330,9 @@ bool test_ChangePasswordUser3(struct dcerpc_pipe *p, struct torture_context *tct
                }
 
        } else if (NT_STATUS_EQUAL(status, NT_STATUS_PASSWORD_RESTRICTION)) {
-               if (reject && reject->reason != SAMR_REJECT_OTHER) {
-                       torture_warning(tctx, "expected SAMR_REJECT_OTHER (%d), got %d\n",
-                              SAMR_REJECT_OTHER, reject->reason);
+               if (reject && reject->extendedFailureReason != SAM_PWD_CHANGE_NO_ERROR) {
+                       torture_warning(tctx, "expected SAM_PWD_CHANGE_NO_ERROR (%d), got %d\n",
+                              SAM_PWD_CHANGE_NO_ERROR, reject->extendedFailureReason);
                        return false;
                }
                /* Perhaps the server has a 'min password age' set? */
@@ -2369,7 +2369,7 @@ bool test_ChangePasswordRandomBytes(struct dcerpc_pipe *p, struct torture_contex
        uint8_t old_nt_hash[16], new_nt_hash[16];
        NTTIME t;
        struct samr_DomInfo1 *dominfo = NULL;
-       struct samr_ChangeReject *reject = NULL;
+       struct userPwdChangeFailureInformation *reject = NULL;
 
        new_random_pass = samr_very_rand_pass(tctx, 128);
 
@@ -2444,9 +2444,9 @@ bool test_ChangePasswordRandomBytes(struct dcerpc_pipe *p, struct torture_contex
        status = dcerpc_samr_ChangePasswordUser3(p, tctx, &r);
 
        if (NT_STATUS_EQUAL(status, NT_STATUS_PASSWORD_RESTRICTION)) {
-               if (reject && reject->reason != SAMR_REJECT_OTHER) {
-                       torture_warning(tctx, "expected SAMR_REJECT_OTHER (%d), got %d\n",
-                              SAMR_REJECT_OTHER, reject->reason);
+               if (reject && reject->extendedFailureReason != SAM_PWD_CHANGE_NO_ERROR) {
+                       torture_warning(tctx, "expected SAM_PWD_CHANGE_NO_ERROR (%d), got %d\n",
+                              SAM_PWD_CHANGE_NO_ERROR, reject->extendedFailureReason);
                        return false;
                }
                /* Perhaps the server has a 'min password age' set? */
@@ -2482,9 +2482,9 @@ bool test_ChangePasswordRandomBytes(struct dcerpc_pipe *p, struct torture_contex
        status = dcerpc_samr_ChangePasswordUser3(p, tctx, &r);
 
        if (NT_STATUS_EQUAL(status, NT_STATUS_PASSWORD_RESTRICTION)) {
-               if (reject && reject->reason != SAMR_REJECT_OTHER) {
-                       torture_warning(tctx, "expected SAMR_REJECT_OTHER (%d), got %d\n",
-                              SAMR_REJECT_OTHER, reject->reason);
+               if (reject && reject->extendedFailureReason != SAM_PWD_CHANGE_NO_ERROR) {
+                       torture_warning(tctx, "expected SAM_PWD_CHANGE_NO_ERROR (%d), got %d\n",
+                              SAM_PWD_CHANGE_NO_ERROR, reject->extendedFailureReason);
                        return false;
                }
                /* Perhaps the server has a 'min password age' set? */
@@ -6754,6 +6754,35 @@ static bool test_Connect(struct dcerpc_pipe *p, struct torture_context *tctx,
 }
 
 
+static bool test_samr_ValidatePassword(struct dcerpc_pipe *p, struct torture_context *tctx)
+{
+       struct samr_ValidatePassword r;
+       union samr_ValidatePasswordReq req;
+       union samr_ValidatePasswordRep *repp = NULL;
+       NTSTATUS status;
+       const char *passwords[] = { "penguin", "p@ssw0rd", "p@ssw0rd123$", NULL };
+       int i;
+
+       ZERO_STRUCT(r);
+       r.in.level = NetValidatePasswordReset;
+       r.in.req = &req;
+       r.out.rep = &repp;
+       
+       ZERO_STRUCT(req);
+       req.req3.account.string = "non-existant-account-aklsdji";
+
+       for (i=0; passwords[i]; i++) {
+               req.req3.password.string = passwords[i];
+               status = dcerpc_samr_ValidatePassword(p, tctx, &r);
+               torture_assert_ntstatus_ok(tctx, status, "samr_ValidatePassword");
+               torture_comment(tctx, "Server %s password '%s'\n", 
+                               repp->ctr3.status==SAMR_VALIDATION_STATUS_SUCCESS?"allowed":"refused",
+                               req.req3.password.string);
+       }
+
+       return true;    
+}
+
 bool torture_rpc_samr(struct torture_context *torture)
 {
        NTSTATUS status;
@@ -6766,6 +6795,11 @@ bool torture_rpc_samr(struct torture_context *torture)
                return false;
        }
 
+
+       if (torture_setting_bool(torture, "dangerous", false)) {
+               ret &= test_samr_ValidatePassword(p, torture);
+       }
+
        ret &= test_Connect(p, torture, &handle);
 
        if (!torture_setting_bool(torture, "samba3", false)) {
@@ -7008,3 +7042,4 @@ struct torture_suite *torture_rpc_samr_large_dc(TALLOC_CTX *mem_ctx)
 
        return suite;
 }
+

diff --git a/source4/torture/rpc/samsync.c b/source4/torture/rpc/samsync.c
index 4cecab40171974783e9bf08ecfe17dd3bf28e19c..2ee8e59e5aec6e2e2577825af1bb75b3a2bee60d 100644 (file)
--- a/source4/torture/rpc/samsync.c
+++ b/source4/torture/rpc/samsync.c
@@ -28,7 +28,7 @@
 #include "../lib/crypto/crypto.h"
 #include "system/time.h"
 #include "torture/rpc/rpc.h"
-#include "auth/gensec/schannel_proto.h"
+#include "../libcli/auth/schannel.h"
 #include "auth/gensec/gensec.h"
 #include "libcli/auth/libcli_auth.h"
 #include "libcli/samsync/samsync.h"

diff --git a/source4/torture/rpc/schannel.c b/source4/torture/rpc/schannel.c
index 6c539b611714625dca8939a7f53c319d2c05b381..0ada20d888ff640f8a68e7324a371f976dd7186d 100644 (file)
--- a/source4/torture/rpc/schannel.c
+++ b/source4/torture/rpc/schannel.c
@@ -26,7 +26,7 @@
 #include "auth/credentials/credentials.h"
 #include "torture/rpc/rpc.h"
 #include "lib/cmdline/popt_common.h"
-#include "auth/gensec/schannel_proto.h"
+#include "../libcli/auth/schannel.h"
 #include "libcli/auth/libcli_auth.h"
 #include "libcli/security/security.h"
 #include "system/filesys.h"

diff --git a/source4/torture/rpc/wkssvc.c b/source4/torture/rpc/wkssvc.c
index 06b1d05ee4dce2ee8063caf17485569c52e17727..d5ef0a4fdafcfc658c159512672c206a571ff766 100644 (file)
--- a/source4/torture/rpc/wkssvc.c
+++ b/source4/torture/rpc/wkssvc.c
@@ -1132,7 +1132,7 @@ static bool test_NetrJoinDomain(struct torture_context *tctx,
                                        user);
 
        r.in.server_name = dcerpc_server_name(p);
-       r.in.domain_name = lp_realm(tctx->lp_ctx);
+       r.in.domain_name = lp_dnsdomain(tctx->lp_ctx);
        r.in.account_ou = NULL;
        r.in.Account = admin_account;
        r.in.password = NULL;

diff --git a/source4/torture/smb2/compound.c b/source4/torture/smb2/compound.c
index 00f6f3340f59f7a71c169db252cc02ab6235fac0..e9b5ee9408b81e2b0e5a6c0916a19f4fbdbdd343 100644 (file)
--- a/source4/torture/smb2/compound.c
+++ b/source4/torture/smb2/compound.c
@@ -44,7 +44,6 @@ static bool test_compound_related1(struct torture_context *tctx,
        struct smb2_close cl;
        bool ret = true;
        struct smb2_request *req[2];
-       DATA_BLOB data;
 
        smb2_transport_credits_ask_num(tree->session->transport, 2);
 
@@ -170,8 +169,6 @@ static bool test_compound_unrelated1(struct torture_context *tctx,
        struct smb2_close cl;
        bool ret = true;
        struct smb2_request *req[5];
-       uint64_t uid;
-       uint32_t tid;
 
        smb2_transport_credits_ask_num(tree->session->transport, 5);
 
@@ -237,7 +234,6 @@ static bool test_compound_invalid1(struct torture_context *tctx,
        struct smb2_close cl;
        bool ret = true;
        struct smb2_request *req[2];
-       DATA_BLOB data;
 
        smb2_transport_credits_ask_num(tree->session->transport, 2);
 

diff --git a/source4/torture/smb2/config.mk b/source4/torture/smb2/config.mk
index 2aba86a1ab70783714b6cd87477e1d00bce4d785..e26ad26e7f853584367d2c31199691db4021c981 100644 (file)
--- a/source4/torture/smb2/config.mk
+++ b/source4/torture/smb2/config.mk
@@ -20,12 +20,13 @@ TORTURE_SMB2_OBJ_FILES = $(addprefix $(torturesrcdir)/smb2/, \
                notify.o \
                smb2.o \
                durable_open.o \
-               oplocks.o \
+               oplock.o \
                dir.o \
                lease.o \
                create.o \
                read.o \
-               compound.o)
+               compound.o \
+               streams.o)
 
 
 $(eval $(call proto_header_template,$(torturesrcdir)/smb2/proto.h,$(TORTURE_SMB2_OBJ_FILES:.o=.c)))

diff --git a/source4/torture/smb2/create.c b/source4/torture/smb2/create.c
index febfbe03ec4190505cfe6c10cb597927a7ecb584..be825b24a7eca684e529006c826efa44c8474654 100644 (file)
--- a/source4/torture/smb2/create.c
+++ b/source4/torture/smb2/create.c
@@ -23,26 +23,109 @@
 #include "libcli/smb2/smb2.h"
 #include "libcli/smb2/smb2_calls.h"
 #include "torture/torture.h"
+#include "torture/util.h"
 #include "torture/smb2/proto.h"
 #include "librpc/gen_ndr/ndr_security.h"
 #include "libcli/security/security.h"
 
+#include "system/filesys.h"
+#include "auth/credentials/credentials.h"
+#include "lib/cmdline/popt_common.h"
+#include "librpc/gen_ndr/security.h"
+#include "lib/events/events.h"
+
 #define FNAME "test_create.dat"
+#define DNAME "smb2_open"
 
 #define CHECK_STATUS(status, correct) do { \
        if (!NT_STATUS_EQUAL(status, correct)) { \
-               printf("(%s) Incorrect status %s - should be %s\n", \
-                      __location__, nt_errstr(status), nt_errstr(correct)); \
+               torture_result(torture, TORTURE_FAIL, \
+                       "(%s) Incorrect status %s - should be %s\n", \
+                        __location__, nt_errstr(status), nt_errstr(correct)); \
                return false; \
        }} while (0)
 
 #define CHECK_EQUAL(v, correct) do { \
        if (v != correct) { \
-               printf("(%s) Incorrect value for %s 0x%08llx - should be 0x%08llx\n", \
-                      __location__, #v, (unsigned long long)v, (unsigned long long)correct); \
+               torture_result(torture, TORTURE_FAIL, \
+                       "(%s) Incorrect value for %s 0x%08llx - " \
+                       "should be 0x%08llx\n", \
+                        __location__, #v, \
+                       (unsigned long long)v, \
+                       (unsigned long long)correct); \
                return false;                                   \
        }} while (0)
 
+#define CHECK_TIME(t, field) do { \
+       time_t t1, t2; \
+       finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \
+       finfo.all_info.in.file.handle = h1; \
+       status = smb2_getinfo_file(tree, torture, &finfo); \
+       CHECK_STATUS(status, NT_STATUS_OK); \
+       t1 = t & ~1; \
+       t2 = nt_time_to_unix(finfo.all_info.out.field) & ~1; \
+       if (abs(t1-t2) > 2) { \
+               torture_result(torture, TORTURE_FAIL, \
+                       "(%s) wrong time for field %s  %s - %s\n", \
+                       __location__, #field, \
+                       timestring(torture, t1), \
+                       timestring(torture, t2)); \
+               dump_all_info(torture, &finfo); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_NTTIME(t, field) do { \
+       NTTIME t2; \
+       finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \
+       finfo.all_info.in.file.handle = h1; \
+       status = smb2_getinfo_file(tree, torture, &finfo); \
+       CHECK_STATUS(status, NT_STATUS_OK); \
+       t2 = finfo.all_info.out.field; \
+       if (t != t2) { \
+               torture_result(torture, TORTURE_FAIL, \
+                       "(%s) wrong time for field %s  %s - %s\n", \
+                      __location__, #field, \
+                      nt_time_string(torture, t), \
+                      nt_time_string(torture, t2)); \
+               dump_all_info(torture, &finfo); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_ALL_INFO(v, field) do { \
+       finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \
+       finfo.all_info.in.file.handle = h1; \
+       status = smb2_getinfo_file(tree, torture, &finfo); \
+       CHECK_STATUS(status, NT_STATUS_OK); \
+       if ((v) != (finfo.all_info.out.field)) { \
+              torture_result(torture, TORTURE_FAIL, \
+                       "(%s) wrong value for field %s  0x%x - 0x%x\n", \
+                       __location__, #field, (int)v,\
+                       (int)(finfo.all_info.out.field)); \
+               dump_all_info(torture, &finfo); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_VAL(v, correct) do { \
+       if ((v) != (correct)) { \
+               torture_result(torture, TORTURE_FAIL, \
+                       "(%s) wrong value for %s  0x%x - should be 0x%x\n", \
+                      __location__, #v, (int)(v), (int)correct); \
+               ret = false; \
+       }} while (0)
+
+#define SET_ATTRIB(sattrib) do { \
+       union smb_setfileinfo sfinfo; \
+       ZERO_STRUCT(sfinfo.basic_info.in); \
+       sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION; \
+       sfinfo.basic_info.in.file.handle = h1; \
+       sfinfo.basic_info.in.attrib = sattrib; \
+       status = smb2_setinfo_file(tree, &sfinfo); \
+       if (!NT_STATUS_IS_OK(status)) { \
+               torture_comment(torture, \
+                   "(%s) Failed to set attrib 0x%x on %s\n", \
+                      __location__, sattrib, fname); \
+       }} while (0)
+
 #define TARGET_IS_WIN7(_tctx) (torture_setting_bool(_tctx, "win7", false))
 
 /*
@@ -131,7 +214,9 @@ static bool test_create_gentest(struct torture_context *torture, struct smb2_tre
                                CHECK_STATUS(status, NT_STATUS_OK);
                        } else {
                                unexpected_mask |= 1<<i;
-                               printf("create option 0x%08x returned %s\n", 1<<i, nt_errstr(status));
+                               torture_comment(torture,
+                                   "create option 0x%08x returned %s\n",
+                                   1<<i, nt_errstr(status));
                        }
                }
        }
@@ -198,7 +283,9 @@ static bool test_create_gentest(struct torture_context *torture, struct smb2_tre
                                CHECK_STATUS(status, NT_STATUS_OK);
                        } else {
                                unexpected_mask |= 1<<i;
-                               printf("file attribute 0x%08x returned %s\n", 1<<i, nt_errstr(status));
+                               torture_comment(torture,
+                                   "file attribute 0x%08x returned %s\n",
+                                   1<<i, nt_errstr(status));
                        }
                }
        }
@@ -216,7 +303,9 @@ static bool test_create_gentest(struct torture_context *torture, struct smb2_tre
        io.in.file_attributes = FILE_ATTRIBUTE_ENCRYPTED;
        status = smb2_create(tree, tmp_ctx, &io);
        if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
-               printf("FILE_ATTRIBUTE_ENCRYPTED returned %s\n", nt_errstr(status));
+               torture_comment(torture,
+                   "FILE_ATTRIBUTE_ENCRYPTED returned %s\n",
+                   nt_errstr(status));
        } else {
                CHECK_STATUS(status, NT_STATUS_OK);
                CHECK_EQUAL(io.out.file_attr, (FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_ARCHIVE));
@@ -308,7 +397,7 @@ static bool test_create_blob(struct torture_context *torture, struct smb2_tree *
        status = smb2_util_close(tree, io.out.file.handle);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("testing alloc size\n");
+       torture_comment(torture, "testing alloc size\n");
        io.in.alloc_size = 4096;
        status = smb2_create(tree, tmp_ctx, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -317,7 +406,7 @@ static bool test_create_blob(struct torture_context *torture, struct smb2_tree *
        status = smb2_util_close(tree, io.out.file.handle);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("testing durable open\n");
+       torture_comment(torture, "testing durable open\n");
        io.in.durable_open = true;
        status = smb2_create(tree, tmp_ctx, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -325,7 +414,7 @@ static bool test_create_blob(struct torture_context *torture, struct smb2_tree *
        status = smb2_util_close(tree, io.out.file.handle);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("testing query maximal access\n");
+       torture_comment(torture, "testing query maximal access\n");
        io.in.query_maximal_access = true;
        status = smb2_create(tree, tmp_ctx, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -334,13 +423,13 @@ static bool test_create_blob(struct torture_context *torture, struct smb2_tree *
        status = smb2_util_close(tree, io.out.file.handle);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("testing timewarp\n");
+       torture_comment(torture, "testing timewarp\n");
        io.in.timewarp = 10000;
        status = smb2_create(tree, tmp_ctx, &io);
        CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
        io.in.timewarp = 0;
 
-       printf("testing query_on_disk\n");
+       torture_comment(torture, "testing query_on_disk\n");
        io.in.query_on_disk_id = true;
        status = smb2_create(tree, tmp_ctx, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -348,7 +437,7 @@ static bool test_create_blob(struct torture_context *torture, struct smb2_tree *
        status = smb2_util_close(tree, io.out.file.handle);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("testing unknown tag\n");
+       torture_comment(torture, "testing unknown tag\n");
        status = smb2_create_blob_add(tmp_ctx, &io.in.blobs,
                                      "FooO", data_blob(NULL, 0));
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -359,7 +448,7 @@ static bool test_create_blob(struct torture_context *torture, struct smb2_tree *
        status = smb2_util_close(tree, io.out.file.handle);
        CHECK_STATUS(status, NT_STATUS_OK);
 
-       printf("testing bad tag length\n");
+       torture_comment(torture, "testing bad tag length\n");
        status = smb2_create_blob_add(tmp_ctx, &io.in.blobs,
                                      "xxx", data_blob(NULL, 0));
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -421,7 +510,7 @@ static bool test_create_acl(struct torture_context *torture, struct smb2_tree *t
 
        smb2_util_unlink(tree, FNAME);
 
-       printf("adding a new ACE\n");
+       torture_comment(torture, "adding a new ACE\n");
        test_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-5-32-1234-54321");
 
        ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
@@ -431,8 +520,8 @@ static bool test_create_acl(struct torture_context *torture, struct smb2_tree *t
 
        status = security_descriptor_dacl_add(sd, &ace);
        CHECK_STATUS(status, NT_STATUS_OK);
-       
-       printf("creating a file with an initial ACL\n");
+
+       torture_comment(torture, "creating a file with an initial ACL\n");
 
        io.in.sec_desc = sd;
        status = smb2_create(tree, tmp_ctx, &io);
@@ -444,10 +533,11 @@ static bool test_create_acl(struct torture_context *torture, struct smb2_tree *t
        sd2 = q.query_secdesc.out.sd;
 
        if (!security_acl_equal(sd->dacl, sd2->dacl)) {
-               printf("%s: security descriptors don't match!\n", __location__);
-               printf("got:\n");
+               torture_comment(torture,
+                   "%s: security descriptors don't match!\n", __location__);
+               torture_comment(torture, "got:\n");
                NDR_PRINT_DEBUG(security_descriptor, sd2);
-               printf("expected:\n");
+               torture_comment(torture, "expected:\n");
                NDR_PRINT_DEBUG(security_descriptor, sd);
                return false;
        }
@@ -457,7 +547,496 @@ static bool test_create_acl(struct torture_context *torture, struct smb2_tree *t
        return true;
 }
 
-/* 
+/*
+  test SMB2 open
+*/
+static bool test_smb2_open(struct torture_context *torture,
+                          struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(torture);
+       union smb_open io;
+       union smb_fileinfo finfo;
+       const char *fname = DNAME "\\torture_ntcreatex.txt";
+       const char *dname = DNAME "\\torture_ntcreatex.dir";
+       NTSTATUS status;
+       struct smb2_handle h, h1;
+       bool ret = true;
+       int i;
+       struct {
+               uint32_t create_disp;
+               bool with_file;
+               NTSTATUS correct_status;
+       } open_funcs[] = {
+               { NTCREATEX_DISP_SUPERSEDE,     true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_SUPERSEDE,     false, NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN,          true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN,          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
+               { NTCREATEX_DISP_CREATE,        true,  NT_STATUS_OBJECT_NAME_COLLISION },
+               { NTCREATEX_DISP_CREATE,        false, NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN_IF,       true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_OPEN_IF,       false, NT_STATUS_OK },
+               { NTCREATEX_DISP_OVERWRITE,     true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_OVERWRITE,     false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
+               { NTCREATEX_DISP_OVERWRITE_IF,  true,  NT_STATUS_OK },
+               { NTCREATEX_DISP_OVERWRITE_IF,  false, NT_STATUS_OK },
+               { 6,                            true,  NT_STATUS_INVALID_PARAMETER },
+               { 6,                            false, NT_STATUS_INVALID_PARAMETER },
+       };
+
+       torture_comment(torture, "Checking SMB2 Open\n");
+
+       smb2_util_unlink(tree, fname);
+       smb2_util_rmdir(tree, dname);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ZERO_STRUCT(io.smb2);
+       /* reasonable default parameters */
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 1024*1024;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /* test the create disposition */
+       for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
+               if (open_funcs[i].with_file) {
+                       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+                       status= smb2_create(tree, mem_ctx, &(io.smb2));
+                       if (!NT_STATUS_IS_OK(status)) {
+                               torture_comment(torture,
+                                   "Failed to create file %s status %s %d\n",
+                                   fname, nt_errstr(status), i);
+
+                               ret = false;
+                               goto done;
+                       }
+                       smb2_util_close(tree, io.smb2.out.file.handle);
+               }
+               io.smb2.in.create_disposition = open_funcs[i].create_disp;
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
+                       torture_comment(torture,
+                           "(%s) incorrect status %s should be %s (i=%d "
+                           "with_file=%d open_disp=%d)\n",
+                        __location__, nt_errstr(status),
+                       nt_errstr(open_funcs[i].correct_status),
+                       i, (int)open_funcs[i].with_file,
+                       (int)open_funcs[i].create_disp);
+
+                       ret = false;
+                       goto done;
+               }
+               if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {
+                       smb2_util_close(tree, io.smb2.out.file.handle);
+                       smb2_util_unlink(tree, fname);
+               }
+       }
+
+       /* basic field testing */
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       CHECK_VAL(io.smb2.out.oplock_level, 0);
+       CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);
+       CHECK_NTTIME(io.smb2.out.create_time, create_time);
+       CHECK_NTTIME(io.smb2.out.access_time, access_time);
+       CHECK_NTTIME(io.smb2.out.write_time, write_time);
+       CHECK_NTTIME(io.smb2.out.change_time, change_time);
+       CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
+       CHECK_ALL_INFO(io.smb2.out.alloc_size, alloc_size);
+       CHECK_ALL_INFO(io.smb2.out.size, size);
+
+       /* check fields when the file already existed */
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+
+       status = smb2_create_complex_file(tree, fname, &h1);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, h1);
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       CHECK_VAL(io.smb2.out.oplock_level, 0);
+       CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_EXISTED);
+       CHECK_NTTIME(io.smb2.out.create_time, create_time);
+       CHECK_NTTIME(io.smb2.out.access_time, access_time);
+       CHECK_NTTIME(io.smb2.out.write_time, write_time);
+       CHECK_NTTIME(io.smb2.out.change_time, change_time);
+       CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
+       CHECK_ALL_INFO(io.smb2.out.alloc_size, alloc_size);
+       CHECK_ALL_INFO(io.smb2.out.size, size);
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+
+       /* create a directory */
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.fname = dname;
+       fname = dname;
+
+       smb2_util_rmdir(tree, fname);
+       smb2_util_unlink(tree, fname);
+
+       io.smb2.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       CHECK_VAL(io.smb2.out.oplock_level, 0);
+       CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);
+       CHECK_NTTIME(io.smb2.out.create_time, create_time);
+       CHECK_NTTIME(io.smb2.out.access_time, access_time);
+       CHECK_NTTIME(io.smb2.out.write_time, write_time);
+       CHECK_NTTIME(io.smb2.out.change_time, change_time);
+       CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
+       CHECK_VAL(io.smb2.out.file_attr & ~FILE_ATTRIBUTE_NONINDEXED,
+                 FILE_ATTRIBUTE_DIRECTORY);
+       CHECK_ALL_INFO(io.smb2.out.alloc_size, alloc_size);
+       CHECK_ALL_INFO(io.smb2.out.size, size);
+       CHECK_VAL(io.smb2.out.size, 0);
+       CHECK_VAL(io.smb2.out.alloc_size, 0);
+       smb2_util_unlink(tree, fname);
+
+done:
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+       return ret;
+}
+
+/*
+  test with an already opened and byte range locked file
+*/
+
+static bool test_smb2_open_brlocked(struct torture_context *torture,
+                                   struct smb2_tree *tree)
+{
+       union smb_open io, io1;
+       union smb_lock io2;
+       struct smb2_lock_element lock[1];
+       const char *fname = DNAME "\\torture_ntcreatex.txt";
+       NTSTATUS status;
+       bool ret = true;
+       struct smb2_handle h;
+
+       torture_comment(torture,
+               "Testing SMB2 open with a byte range locked file\n");
+
+       smb2_util_unlink(tree, fname);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.desired_access = 0x2019f;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+               NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
+       io.smb2.in.security_flags = SMB2_SECURITY_DYNAMIC_TRACKING;
+       io.smb2.in.fname = fname;
+
+       status = smb2_create(tree, torture, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ZERO_STRUCT(io2.smb2);
+       io2.smb2.level = RAW_LOCK_SMB2;
+       io2.smb2.in.file.handle = io.smb2.out.file.handle;
+       io2.smb2.in.lock_count = 1;
+
+       lock[0].offset = 0;
+       lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
+                       SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
+       io2.smb2.in.locks = &lock[0];
+       status = smb2_lock(tree, &(io2.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ZERO_STRUCT(io1.smb2);
+       io1.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io1.smb2.in.desired_access = 0x20196;
+       io1.smb2.in.alloc_size = 0;
+       io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+               NTCREATEX_SHARE_ACCESS_WRITE;
+       io1.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
+       io1.smb2.in.create_options = 0;
+       io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
+       io1.smb2.in.security_flags = SMB2_SECURITY_DYNAMIC_TRACKING;
+       io1.smb2.in.fname = fname;
+
+       status = smb2_create(tree, torture, &(io1.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, io.smb2.out.file.handle);
+       smb2_util_close(tree, io1.smb2.out.file.handle);
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       return ret;
+}
+
+/* A little torture test to expose a race condition in Samba 3.0.20 ... :-) */
+
+static bool test_smb2_open_multi(struct torture_context *torture,
+                               struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_init("torture_test_oplock_multi");
+       const char *fname = "test_oplock.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_tree **trees;
+       struct smb2_request **requests;
+       union smb_open *ios;
+       int i, num_files = 3;
+       int num_ok = 0;
+       int num_collision = 0;
+
+       if (mem_ctx == NULL) {
+               ret = false;
+               goto done;
+       }
+
+       torture_comment(torture,
+               "Testing SMB2 Open with multiple connections\n");
+       trees = talloc_array(mem_ctx, struct smb2_tree *, num_files);
+       requests = talloc_array(mem_ctx, struct smb2_request *, num_files);
+       ios = talloc_array(mem_ctx, union smb_open, num_files);
+       if ((torture->ev == NULL) || (trees == NULL) || (requests == NULL) ||
+           (ios == NULL)) {
+               torture_comment(torture, ("talloc failed\n"));
+               ret = false;
+               goto done;
+       }
+
+       tree->session->transport->options.request_timeout = 60;
+
+       for (i=0; i<num_files; i++) {
+               if (!torture_smb2_connection(torture, &(trees[i]))) {
+                       torture_comment(torture,
+                               "Could not open %d'th connection\n", i);
+                       ret = false;
+                       goto done;
+               }
+               trees[i]->session->transport->options.request_timeout = 60;
+       }
+
+       /* cleanup */
+       smb2_util_unlink(tree, fname);
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+       io.smb2.in.create_flags = 0;
+
+       for (i=0; i<num_files; i++) {
+               ios[i] = io;
+               requests[i] = smb2_create_send(trees[i], &(ios[i].smb2));
+               if (requests[i] == NULL) {
+                       torture_comment(torture,
+                               "could not send %d'th request\n", i);
+                       ret = false;
+                       goto done;
+               }
+       }
+
+       torture_comment(torture, "waiting for replies\n");
+       while (1) {
+               bool unreplied = false;
+               for (i=0; i<num_files; i++) {
+                       if (requests[i] == NULL) {
+                               continue;
+                       }
+                       if (requests[i]->state < SMB2_REQUEST_DONE) {
+                               unreplied = true;
+                               break;
+                       }
+                       status = smb2_create_recv(requests[i], mem_ctx,
+                                                 &(ios[i].smb2));
+
+                       torture_comment(torture,
+                               "File %d returned status %s\n", i,
+                               nt_errstr(status));
+
+                       if (NT_STATUS_IS_OK(status)) {
+                               num_ok += 1;
+                       }
+
+                       if (NT_STATUS_EQUAL(status,
+                                           NT_STATUS_OBJECT_NAME_COLLISION)) {
+                               num_collision += 1;
+                       }
+
+                       requests[i] = NULL;
+               }
+               if (!unreplied) {
+                       break;
+               }
+
+               if (event_loop_once(torture->ev) != 0) {
+                       torture_comment(torture, "event_loop_once failed\n");
+                       ret = false;
+                       goto done;
+               }
+       }
+
+       if ((num_ok != 1) || (num_ok + num_collision != num_files)) {
+               ret = false;
+       }
+done:
+       talloc_free(mem_ctx);
+       smb2_deltree(tree, fname);
+
+       return ret;
+}
+
+/*
+  test opening for delete on a read-only attribute file.
+*/
+
+static bool test_smb2_open_for_delete(struct torture_context *torture,
+                                     struct smb2_tree *tree)
+{
+       union smb_open io;
+       union smb_fileinfo finfo;
+       const char *fname = DNAME "\\torture_open_for_delete.txt";
+       NTSTATUS status;
+       struct smb2_handle h, h1;
+       bool ret = true;
+
+       torture_comment(torture,
+               "Checking SMB2_OPEN for delete on a readonly file.\n");
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, fname);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       /* reasonable default parameters */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_READONLY;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /* Create the readonly file. */
+
+       status = smb2_create(tree, torture, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       CHECK_VAL(io.smb2.out.oplock_level, 0);
+       io.smb2.in.create_options = 0;
+       CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);
+       CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
+       smb2_util_close(tree, h1);
+
+       /* Now try and open for delete only - should succeed. */
+       io.smb2.in.desired_access = SEC_STD_DELETE;
+       io.smb2.in.file_attributes = 0;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE |
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree, torture, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_unlink(tree, fname);
+
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       return ret;
+}
+
+/*
+  test SMB2 open with a leading slash on the path.
+  Trying to create a directory with a leading slash
+  should give NT_STATUS_INVALID_PARAMETER error
+*/
+static bool test_smb2_leading_slash(struct torture_context *torture,
+                                   struct smb2_tree *tree)
+{
+       union smb_open io;
+       const char *dnameslash = "\\"DNAME;
+       NTSTATUS status;
+       bool ret = true;
+
+       torture_comment(torture,
+               "Trying to create a directory with leading slash on path\n");
+       smb2_deltree(tree, dnameslash);
+
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.oplock_level = 0;
+       io.smb2.in.desired_access = SEC_RIGHTS_DIR_ALL;
+       io.smb2.in.file_attributes   = FILE_ATTRIBUTE_DIRECTORY;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE |
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
+       io.smb2.in.fname = dnameslash;
+
+       status = smb2_create(tree, tree, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
+
+       smb2_deltree(tree, dnameslash);
+       return ret;
+}
+
+
+/*
    basic testing of SMB2 read
 */
 struct torture_suite *torture_smb2_create_init(void)
@@ -467,6 +1046,11 @@ struct torture_suite *torture_smb2_create_init(void)
        torture_suite_add_1smb2_test(suite, "GENTEST", test_create_gentest);
        torture_suite_add_1smb2_test(suite, "BLOB", test_create_blob);
        torture_suite_add_1smb2_test(suite, "ACL", test_create_acl);
+       torture_suite_add_1smb2_test(suite, "OPEN", test_smb2_open);
+       torture_suite_add_1smb2_test(suite, "BRLOCKED", test_smb2_open_brlocked);
+       torture_suite_add_1smb2_test(suite, "MULTI", test_smb2_open_multi);
+       torture_suite_add_1smb2_test(suite, "DELETE", test_smb2_open_for_delete);
+       torture_suite_add_1smb2_test(suite, "LEADING-SLASH", test_smb2_leading_slash);
 
        suite->description = talloc_strdup(suite, "SMB2-CREATE tests");
 

diff --git a/source4/torture/smb2/dir.c b/source4/torture/smb2/dir.c
index 3551f9718f4a610bb8129dd094243280653ec3c5..4af6900a810cc02c7ebd7473ffb33be77d0a3a52 100644 (file)
--- a/source4/torture/smb2/dir.c
+++ b/source4/torture/smb2/dir.c
@@ -1105,7 +1105,7 @@ static bool test_file_index(struct torture_context *tctx,
        struct smb2_find f;
        struct smb2_handle h;
        union smb_search_data *d;
-       int count;
+       unsigned count;
 
        smb2_deltree(tree, DNAME);
 
@@ -1223,9 +1223,9 @@ static bool test_large_files(struct torture_context *tctx,
        struct smb2_find f;
        struct smb2_handle h;
        union smb_search_data *d;
-       int count, file_count = 0;
+       int i, j, file_count = 0;
        char **strs = NULL;
-       int i, j;
+       unsigned count;
 
        torture_comment(tctx,
            "Testing directory enumeration in a directory with >1000 files\n");

diff --git a/source4/torture/smb2/oplock.c b/source4/torture/smb2/oplock.c
new file mode 100644 (file)
index 0000000..f686de6
--- /dev/null
+++ b/source4/torture/smb2/oplock.c
@@ -0,0 +1,3617 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   test suite for SMB2 oplocks
+
+   Copyright (C) Andrew Tridgell 2003
+   Copyright (C) Stefan Metzmacher 2008
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+
+#include "libcli/smb2/smb2.h"
+#include "libcli/smb2/smb2_calls.h"
+#include "libcli/smb_composite/smb_composite.h"
+#include "libcli/resolve/resolve.h"
+
+#include "lib/cmdline/popt_common.h"
+#include "lib/events/events.h"
+
+#include "param/param.h"
+#include "system/filesys.h"
+
+#include "torture/torture.h"
+#include "torture/smb2/proto.h"
+
+#define CHECK_RANGE(v, min, max) do { \
+       if ((v) < (min) || (v) > (max)) { \
+               torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s " \
+                              "got %d - should be between %d and %d\n", \
+                               __location__, #v, (int)v, (int)min, (int)max); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_STRMATCH(v, correct) do { \
+       if (!v || strstr((v),(correct)) == NULL) { \
+               torture_result(tctx, TORTURE_FAIL,  "(%s): wrong value for %s "\
+                              "got '%s' - should be '%s'\n", \
+                               __location__, #v, v?v:"NULL", correct); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_VAL(v, correct) do { \
+       if ((v) != (correct)) { \
+               torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s " \
+                              "got 0x%x - should be 0x%x\n", \
+                               __location__, #v, (int)v, (int)correct); \
+               ret = false; \
+       }} while (0)
+
+#define BASEDIR "oplock_test"
+
+static struct {
+       struct smb2_handle handle;
+       uint8_t level;
+       struct smb2_break br;
+       int count;
+       int failures;
+       NTSTATUS failure_status;
+} break_info;
+
+static void torture_oplock_break_callback(struct smb2_request *req)
+{
+       NTSTATUS status;
+       struct smb2_break br;
+
+       ZERO_STRUCT(br);
+       status = smb2_break_recv(req, &break_info.br);
+       if (!NT_STATUS_IS_OK(status)) {
+               break_info.failures++;
+               break_info.failure_status = status;
+       }
+
+       return;
+}
+
+/* A general oplock break notification handler.  This should be used when a
+ * test expects to break from batch or exclusive to a lower level. */
+static bool torture_oplock_handler(struct smb2_transport *transport,
+                                  const struct smb2_handle *handle,
+                                  uint8_t level,
+                                  void *private_data)
+{
+       struct smb2_tree *tree = private_data;
+       const char *name;
+       struct smb2_request *req;
+       ZERO_STRUCT(break_info.br);
+
+       break_info.handle       = *handle;
+       break_info.level        = level;
+       break_info.count++;
+
+       switch (level) {
+       case SMB2_OPLOCK_LEVEL_II:
+               name = "level II";
+               break;
+       case SMB2_OPLOCK_LEVEL_NONE:
+               name = "none";
+               break;
+       default:
+               name = "unknown";
+               break_info.failures++;
+       }
+       printf("Acking to %s [0x%02X] in oplock handler\n", name, level);
+
+       break_info.br.in.file.handle    = *handle;
+       break_info.br.in.oplock_level   = level;
+       break_info.br.in.reserved       = 0;
+       break_info.br.in.reserved2      = 0;
+
+       req = smb2_break_send(tree, &break_info.br);
+       req->async.fn = torture_oplock_break_callback;
+       req->async.private_data = NULL;
+       return true;
+}
+
+/*
+  A handler function for oplock break notifications. Send a break to none
+  request.
+*/
+static bool torture_oplock_handler_ack_to_none(struct smb2_transport *transport,
+                                              const struct smb2_handle *handle,
+                                              uint8_t level,
+                                              void *private_data)
+{
+       struct smb2_tree *tree = private_data;
+       struct smb2_request *req;
+
+       break_info.handle = *handle;
+       break_info.level = level;
+       break_info.count++;
+
+       printf("Acking to none in oplock handler\n");
+
+       ZERO_STRUCT(break_info.br);
+       break_info.br.in.file.handle    = *handle;
+       break_info.br.in.oplock_level   = SMB2_OPLOCK_LEVEL_NONE;
+       break_info.br.in.reserved       = 0;
+       break_info.br.in.reserved2      = 0;
+
+       req = smb2_break_send(tree, &break_info.br);
+       req->async.fn = torture_oplock_break_callback;
+       req->async.private_data = NULL;
+
+       return true;
+}
+
+/*
+  A handler function for oplock break notifications. Break from level II to
+  none.  SMB2 requires that the client does not send an oplock break request to
+  the server in this case.
+*/
+static bool torture_oplock_handler_level2_to_none(
+                                              struct smb2_transport *transport,
+                                              const struct smb2_handle *handle,
+                                              uint8_t level,
+                                              void *private_data)
+{
+       struct smb2_tree *tree = private_data;
+
+       break_info.handle = *handle;
+       break_info.level = level;
+       break_info.count++;
+
+       printf("Break from level II to none in oplock handler\n");
+
+       return true;
+}
+
+/* A handler function for oplock break notifications.  This should be used when
+ * test expects two break notifications, first to level II, then to none. */
+static bool torture_oplock_handler_two_notifications(
+                                       struct smb2_transport *transport,
+                                       const struct smb2_handle *handle,
+                                       uint8_t level,
+                                       void *private_data)
+{
+       struct smb2_tree *tree = private_data;
+       const char *name;
+       struct smb2_request *req;
+       ZERO_STRUCT(break_info.br);
+
+       break_info.handle       = *handle;
+       break_info.level        = level;
+       break_info.count++;
+
+       switch (level) {
+       case SMB2_OPLOCK_LEVEL_II:
+               name = "level II";
+               break;
+       case SMB2_OPLOCK_LEVEL_NONE:
+               name = "none";
+               break;
+       default:
+               name = "unknown";
+               break_info.failures++;
+       }
+       printf("Breaking to %s [0x%02X] in oplock handler\n", name, level);
+
+       if (level == SMB2_OPLOCK_LEVEL_NONE)
+               return true;
+
+       break_info.br.in.file.handle    = *handle;
+       break_info.br.in.oplock_level   = level;
+       break_info.br.in.reserved       = 0;
+       break_info.br.in.reserved2      = 0;
+
+       req = smb2_break_send(tree, &break_info.br);
+       req->async.fn = torture_oplock_break_callback;
+       req->async.private_data = NULL;
+       return true;
+}
+static void torture_oplock_handler_close_recv(struct smb2_request *req)
+{
+       if (!smb2_request_receive(req)) {
+               printf("close failed in oplock_handler_close\n");
+               break_info.failures++;
+       }
+}
+
+/*
+  a handler function for oplock break requests - close the file
+*/
+static bool torture_oplock_handler_close(struct smb2_transport *transport,
+                                        const struct smb2_handle *handle,
+                                        uint8_t level,
+                                        void *private_data)
+{
+       struct smb2_close io;
+       struct smb2_tree *tree = private_data;
+       struct smb2_request *req;
+
+       break_info.handle = *handle;
+       break_info.level = level;
+       break_info.count++;
+
+       ZERO_STRUCT(io);
+       io.in.file.handle       = *handle;
+       io.in.flags          = RAW_CLOSE_SMB2;
+       req = smb2_close_send(tree, &io);
+       if (req == NULL) {
+               printf("failed to send close in oplock_handler_close\n");
+               return false;
+       }
+
+       req->async.fn = torture_oplock_handler_close_recv;
+       req->async.private_data = NULL;
+
+       return true;
+}
+
+/*
+  a handler function for oplock break requests. Let it timeout
+*/
+static bool torture_oplock_handler_timeout(struct smb2_transport *transport,
+                                          const struct smb2_handle *handle,
+                                          uint8_t level,
+                                          void *private_data)
+{
+       break_info.handle = *handle;
+       break_info.level = level;
+       break_info.count++;
+
+       printf("Let oplock break timeout\n");
+       return true;
+}
+
+static bool open_smb2_connection_no_level2_oplocks(struct torture_context *tctx,
+                                                  struct smb2_tree **tree)
+{
+       NTSTATUS status;
+       const char *host = torture_setting_string(tctx, "host", NULL);
+       const char *share = torture_setting_string(tctx, "share", NULL);
+       struct cli_credentials *credentials = cmdline_credentials;
+       struct smbcli_options options;
+
+       lp_smbcli_options(tctx->lp_ctx, &options);
+       options.use_level2_oplocks = false;
+
+       status = smb2_connect(tctx, host,
+                             lp_smb_ports(tctx->lp_ctx), share,
+                             lp_resolve_context(tctx->lp_ctx),
+                             credentials, tree, tctx->ev, &options,
+                             lp_socket_options(tctx->lp_ctx),
+                             lp_gensec_settings(tctx, tctx->lp_ctx));
+       if (!NT_STATUS_IS_OK(status)) {
+               torture_comment(tctx, "Failed to connect to SMB2 share "
+                               "\\\\%s\\%s - %s\n", host, share,
+                               nt_errstr(status));
+               return false;
+       }
+       return true;
+}
+
+/*
+   Timer handler function notifies the registering function that time is up
+*/
+static void timeout_cb(struct tevent_context *ev,
+                      struct tevent_timer *te,
+                      struct timeval current_time,
+                      void *private_data)
+{
+       bool *timesup = (bool *)private_data;
+       *timesup = true;
+       return;
+}
+
+/*
+   Wait a short period of time to receive a single oplock break request
+*/
+static void torture_wait_for_oplock_break(struct torture_context *tctx)
+{
+       TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+       struct tevent_timer *te = NULL;
+       struct timeval ne;
+       bool timesup = false;
+       int old_count = break_info.count;
+
+       /* Wait .1 seconds for an oplock break */
+       ne = tevent_timeval_current_ofs(0, 100000);
+
+       if ((te = event_add_timed(tctx->ev, tmp_ctx, ne, timeout_cb, &timesup))
+           == NULL)
+       {
+               torture_comment(tctx, "Failed to wait for an oplock break. "
+                                     "test results may not be accurate.");
+               goto done;
+       }
+
+       while (!timesup && break_info.count < old_count + 1) {
+               if (event_loop_once(tctx->ev) != 0) {
+                       torture_comment(tctx, "Failed to wait for an oplock "
+                                             "break. test results may not be "
+                                             "accurate.");
+                       goto done;
+               }
+       }
+
+done:
+       /* We don't know if the timed event fired and was freed, we received
+        * our oplock break, or some other event triggered the loop.  Thus,
+        * we create a tmp_ctx to be able to safely free/remove the timed
+        * event in all 3 cases. */
+       talloc_free(tmp_ctx);
+
+       return;
+}
+
+static bool test_smb2_oplock_exclusive1(struct torture_context *tctx,
+                                       struct smb2_tree *tree1,
+                                       struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_exclusive1.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_unlink unl;
+       struct smb2_handle h1;
+       struct smb2_handle h;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "EXCLUSIVE1: open a file with an exclusive "
+                       "oplock (share mode: none)\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+
+       torture_comment(tctx, "a 2nd open should not cause a break\n");
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       torture_comment(tctx, "unlink it - should also be no break\n");
+       unl.unlink.in.pattern = fname;
+       unl.unlink.in.attrib = 0;
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_exclusive2(struct torture_context *tctx,
+                                       struct smb2_tree *tree1,
+                                       struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_exclusive2.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_unlink unl;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "EXCLUSIVE2: open a file with an exclusive "
+                       "oplock (share mode: all)\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+
+       torture_comment(tctx, "a 2nd open should cause a break to level 2\n");
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h2 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+       ZERO_STRUCT(break_info);
+
+       /* now we have 2 level II oplocks... */
+       torture_comment(tctx, "try to unlink it - should cause a break\n");
+       unl.unlink.in.pattern = fname;
+       unl.unlink.in.attrib = 0;
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_ok(tctx, status, "Error unlinking the file");
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       torture_comment(tctx, "close both handles\n");
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_exclusive3(struct torture_context *tctx,
+                                       struct smb2_tree *tree1,
+                                       struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_exclusive3.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_setfileinfo sfi;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "EXCLUSIVE3: open a file with an exclusive "
+                       "oplock (share mode: none)\n");
+
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+
+       torture_comment(tctx, "setpathinfo EOF should trigger a break to "
+                       "none\n");
+       ZERO_STRUCT(sfi);
+       sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
+       sfi.generic.in.file.path = fname;
+       sfi.end_of_file_info.in.size = 100;
+
+       status = smb2_composite_setpathinfo(tree2, &sfi);
+
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_exclusive4(struct torture_context *tctx,
+                                       struct smb2_tree *tree1,
+                                       struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_exclusive4.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "EXCLUSIVE4: open with exclusive oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+
+       ZERO_STRUCT(break_info);
+       torture_comment(tctx, "second open with attributes only shouldn't "
+                       "cause oplock break\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, NO_OPLOCK_RETURN);
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_exclusive5(struct torture_context *tctx,
+                                       struct smb2_tree *tree1,
+                                       struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_exclusive5.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "EXCLUSIVE5: open with exclusive oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "second open with attributes only and "
+                       "NTCREATEX_DISP_OVERWRITE_IF dispostion causes "
+                       "oplock break\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_II;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_exclusive6(struct torture_context *tctx,
+                                       struct smb2_tree *tree1,
+                                       struct smb2_tree *tree2)
+{
+       const char *fname1 = BASEDIR "\\test_exclusive6_1.dat";
+       const char *fname2 = BASEDIR "\\test_exclusive6_2.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_setfileinfo sinfo;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname1);
+       smb2_util_unlink(tree2, fname2);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname1;
+
+       torture_comment(tctx, "EXCLUSIVE6: open a file with an exclusive "
+                       "oplock (share mode: none)\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+
+       torture_comment(tctx, "rename should not generate a break but get "
+                       "a sharing violation\n");
+       ZERO_STRUCT(sinfo);
+       sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.overwrite = true;
+       sinfo.rename_information.in.new_name = fname2;
+       status = smb2_setinfo_file(tree1, &sinfo);
+
+       torture_comment(tctx, "trying rename while first file open\n");
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch1(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch1.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+       char c = 0;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+         with a batch oplock we get a break
+       */
+       torture_comment(tctx, "BATCH1: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "unlink should generate a break\n");
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+
+       torture_comment(tctx, "2nd unlink should not generate a break\n");
+       ZERO_STRUCT(break_info);
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       torture_comment(tctx, "writing should generate a self break to none\n");
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_level2_to_none;
+       smb2_util_write(tree1, h1, &c, 0, 1);
+
+       torture_wait_for_oplock_break(tctx);
+
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_NONE);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch2(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch2.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       char c = 0;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH2: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "unlink should generate a break, which we ack "
+                       "as break to none\n");
+       tree1->session->transport->oplock.handler =
+                               torture_oplock_handler_ack_to_none;
+       tree1->session->transport->oplock.private_data = tree1;
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                    "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+
+       torture_comment(tctx, "2nd unlink should not generate a break\n");
+       ZERO_STRUCT(break_info);
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       torture_comment(tctx, "writing should not generate a break\n");
+       smb2_util_write(tree1, h1, &c, 0, 1);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch3(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch3.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH3: if we close on break then the unlink "
+                       "can succeed\n");
+       ZERO_STRUCT(break_info);
+       tree1->session->transport->oplock.handler =
+                                       torture_oplock_handler_close;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+       status = smb2_util_unlink(tree2, fname);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch4(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch4.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_read r;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH4: a self read should not cause a break\n");
+       ZERO_STRUCT(break_info);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(r);
+       r.in.file.handle = h1;
+       r.in.offset      = 0;
+
+       status = smb2_read(tree1, tree1, &r);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch5(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch5.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH5: a 2nd open should give a break\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch6(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch6.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+       char c = 0;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH6: a 2nd open should give a break to "
+                       "level II if the first open allowed shared read\n");
+       ZERO_STRUCT(break_info);
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                               SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, 1);
+       CHECK_VAL(break_info.failures, 0);
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "write should trigger a break to none on both\n");
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_level2_to_none;
+       tree2->session->transport->oplock.handler =
+           torture_oplock_handler_level2_to_none;
+       smb2_util_write(tree1, h1, &c, 0, 1);
+
+       /* We expect two breaks */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+
+       CHECK_VAL(break_info.count, 2);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch7(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch7.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH7: a 2nd open should get an oplock when "
+                       "we close instead of ack\n");
+       ZERO_STRUCT(break_info);
+       tree1->session->transport->oplock.handler =
+                       torture_oplock_handler_close;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h2.data[0]);
+       CHECK_VAL(break_info.level, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree2, h1);
+       smb2_util_close(tree2, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch8(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch8.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH8: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+       torture_comment(tctx, "second open with attributes only shouldn't "
+                       "cause oplock break\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch9(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch9.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+       char c = 0;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH9: open with attributes only can create "
+                       "file\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "Subsequent normal open should break oplock on "
+                       "attribute only open to level II\n");
+
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+       smb2_util_close(tree2, h2);
+
+       torture_comment(tctx, "third oplocked open should grant level2 without "
+                       "break\n");
+       ZERO_STRUCT(break_info);
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "write should trigger a break to none on both\n");
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_level2_to_none;
+       tree2->session->transport->oplock.handler =
+           torture_oplock_handler_level2_to_none;
+       smb2_util_write(tree2, h2, &c, 0, 1);
+
+       /* We expect two breaks */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+
+       CHECK_VAL(break_info.count, 2);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch10(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch10.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH10: Open with oplock after a non-oplock "
+                       "open should grant level2\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(io.smb2.out.oplock_level, 0);
+
+       tree2->session->transport->oplock.handler =
+           torture_oplock_handler_level2_to_none;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_comment(tctx, "write should trigger a break to none\n");
+       {
+               struct smb2_write wr;
+               DATA_BLOB data;
+               data = data_blob_talloc(tree1, NULL, UINT16_MAX);
+               data.data[0] = (const uint8_t)'x';
+               ZERO_STRUCT(wr);
+               wr.in.file.handle = h1;
+               wr.in.offset      = 0;
+               wr.in.data        = data;
+               status = smb2_write(tree1, &wr);
+               torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       }
+
+       torture_wait_for_oplock_break(tctx);
+
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h2.data[0]);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch11(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch11.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_setfileinfo sfi;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_two_notifications;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /* Test if a set-eof on pathname breaks an exclusive oplock. */
+       torture_comment(tctx, "BATCH11: Test if setpathinfo set EOF breaks "
+                       "oplocks.\n");
+
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h1 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(sfi);
+       sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
+       sfi.generic.in.file.path = fname;
+       sfi.end_of_file_info.in.size = 100;
+
+       status = smb2_composite_setpathinfo(tree2, &sfi);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       /* We expect two breaks */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+
+       CHECK_VAL(break_info.count, 2);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.level, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch12(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch12.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_setfileinfo sfi;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_two_notifications;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /* Test if a set-allocation size on pathname breaks an exclusive
+        * oplock. */
+       torture_comment(tctx, "BATCH12: Test if setpathinfo allocation size "
+                       "breaks oplocks.\n");
+
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h1 = io.smb2.out.file.handle;
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(sfi);
+       sfi.generic.level = RAW_SFILEINFO_ALLOCATION_INFORMATION;
+       sfi.generic.in.file.path = fname;
+       sfi.allocation_info.in.alloc_size = 65536 * 8;
+
+       status = smb2_composite_setpathinfo(tree2, &sfi);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       /* We expect two breaks */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+
+       CHECK_VAL(break_info.count, 2);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.level, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch13(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch13.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH13: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "second open with attributes only and "
+                       "NTCREATEX_DISP_OVERWRITE dispostion causes "
+                       "oplock break\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+
+       return ret;
+}
+
+static bool test_smb2_oplock_batch14(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch14.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH14: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "second open with attributes only and "
+                       "NTCREATEX_DISP_SUPERSEDE dispostion causes "
+                       "oplock break\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch15(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch15.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_fileinfo qfi;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /* Test if a qpathinfo all info on pathname breaks a batch oplock. */
+       torture_comment(tctx, "BATCH15: Test if qpathinfo all info breaks "
+                       "a batch oplock (should not).\n");
+
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(qfi);
+       qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
+       qfi.generic.in.file.handle = h1;
+       status = smb2_getinfo_file(tree2, tctx, &qfi);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch16(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch16.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH16: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "second open with attributes only and "
+                       "NTCREATEX_DISP_OVERWRITE_IF dispostion causes "
+                       "oplock break\n");
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_STD_SYNCHRONIZE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+/* This function is a placeholder for the SMB1 RAW-OPLOCK-BATCH17 test.  Since
+ * SMB2 doesn't have a RENAME command this test isn't applicable.  However,
+ * it's much less confusing, when comparing test, to keep the SMB1 and SMB2
+ * test numbers in sync. */
+#if 0
+static bool test_raw_oplock_batch17(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       return true;
+}
+#endif
+
+/* This function is a placeholder for the SMB1 RAW-OPLOCK-BATCH18 test.  Since
+ * SMB2 doesn't have an NTRENAME command this test isn't applicable.  However,
+ * it's much less confusing, when comparing tests, to keep the SMB1 and SMB2
+ * test numbers in sync. */
+#if 0
+static bool test_raw_oplock_batch18(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       return true;
+}
+#endif
+
+static bool test_smb2_oplock_batch19(struct torture_context *tctx,
+                                    struct smb2_tree *tree1)
+{
+       const char *fname1 = BASEDIR "\\test_batch19_1.dat";
+       const char *fname2 = BASEDIR "\\test_batch19_2.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_fileinfo qfi;
+       union smb_setfileinfo sfi;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname1);
+       smb2_util_unlink(tree1, fname2);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname1;
+
+       torture_comment(tctx, "BATCH19: open a file with an batch oplock "
+                       "(share mode: none)\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "setfileinfo rename info should not trigger "
+                       "a break but should cause a sharing violation\n");
+       ZERO_STRUCT(sfi);
+       sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sfi.generic.in.file.path = fname1;
+       sfi.rename_information.in.file.handle   = h1;
+       sfi.rename_information.in.overwrite     = 0;
+       sfi.rename_information.in.root_fid      = 0;
+       sfi.rename_information.in.new_name      = fname2;
+
+       status = smb2_setinfo_file(tree1, &sfi);
+
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       ZERO_STRUCT(qfi);
+       qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
+       qfi.generic.in.file.handle = h1;
+
+       status = smb2_getinfo_file(tree1, tctx, &qfi);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, fname1);
+       smb2_deltree(tree1, fname2);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch20(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname1 = BASEDIR "\\test_batch20_1.dat";
+       const char *fname2 = BASEDIR "\\test_batch20_2.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       union smb_fileinfo qfi;
+       union smb_setfileinfo sfi;
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname1);
+       smb2_util_unlink(tree1, fname2);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname1;
+
+       torture_comment(tctx, "BATCH20: open a file with an batch oplock "
+                       "(share mode: all)\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "setfileinfo rename info should not trigger "
+                       "a break but should cause a sharing violation\n");
+       ZERO_STRUCT(sfi);
+       sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sfi.rename_information.in.file.handle   = h1;
+       sfi.rename_information.in.overwrite     = 0;
+       sfi.rename_information.in.new_name      = fname2;
+
+       status = smb2_setinfo_file(tree1, &sfi);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       ZERO_STRUCT(qfi);
+       qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
+       qfi.generic.in.file.handle = h1;
+
+       status = smb2_getinfo_file(tree1, tctx, &qfi);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
+
+       torture_comment(tctx, "open the file a second time requesting batch "
+                       "(share mode: all)\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+                               NTCREATEX_SHARE_ACCESS_WRITE|
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.fname = fname1;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_comment(tctx, "setfileinfo rename info should not trigger "
+                       "a break but should cause a sharing violation\n");
+       ZERO_STRUCT(break_info);
+       ZERO_STRUCT(sfi);
+       sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sfi.rename_information.in.file.handle   = h2;
+       sfi.rename_information.in.overwrite     = 0;
+       sfi.rename_information.in.new_name      = fname2;
+
+       status = smb2_setinfo_file(tree2, &sfi);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       ZERO_STRUCT(qfi);
+       qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
+       qfi.generic.in.file.handle = h1;
+
+       status = smb2_getinfo_file(tree1, tctx, &qfi);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
+
+       ZERO_STRUCT(qfi);
+       qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
+       qfi.generic.in.file.handle = h2;
+
+       status = smb2_getinfo_file(tree2, tctx, &qfi);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, fname1);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch21(struct torture_context *tctx,
+                                    struct smb2_tree *tree1)
+{
+       const char *fname = BASEDIR "\\test_batch21.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+       char c = 0;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+         with a batch oplock we get a break
+       */
+       torture_comment(tctx, "BATCH21: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "writing should not generate a break\n");
+       status = smb2_util_write(tree1, h1, &c, 0, 1);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch22(struct torture_context *tctx,
+                                    struct smb2_tree *tree1)
+{
+       const char *fname = BASEDIR "\\test_batch22.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+       struct timeval tv;
+       int timeout = torture_setting_int(tctx, "oplocktimeout", 30);
+       int te;
+
+       if (torture_setting_bool(tctx, "samba3", false)) {
+               torture_skip(tctx, "BATCH22 disabled against samba3\n");
+       }
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+         with a batch oplock we get a break
+       */
+       torture_comment(tctx, "BATCH22: open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
+               NTCREATEX_SHARE_ACCESS_WRITE|
+               NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "a 2nd open should succeed after the oplock "
+                       "break timeout\n");
+       tv = timeval_current();
+       tree1->session->transport->oplock.handler =
+                               torture_oplock_handler_timeout;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       te = (int)timeval_elapsed(&tv);
+       CHECK_RANGE(te, timeout - 1, timeout + 15);
+       torture_comment(tctx, "waited %d seconds for oplock timeout\n", te);
+
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h2);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch23(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch23.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2, h3;
+       struct smb2_tree *tree3 = NULL;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       ret = open_smb2_connection_no_level2_oplocks(tctx, &tree3);
+       CHECK_VAL(ret, true);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       tree3->session->transport->oplock.handler = torture_oplock_handler;
+       tree3->session->transport->oplock.private_data = tree3;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH23: an open and ask for a batch oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                               SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "a 2nd open without level2 oplock support "
+                       "should generate a break to level2\n");
+       status = smb2_create(tree3, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h3 = io.smb2.out.file.handle;
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "a 3rd open with level2 oplock support should "
+                       "not generate a break\n");
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree3, h3);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch24(struct torture_context *tctx,
+                                    struct smb2_tree *tree1,
+                                    struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch24.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1, h2;
+       struct smb2_tree *tree3 = NULL;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       ret = open_smb2_connection_no_level2_oplocks(tctx, &tree3);
+       CHECK_VAL(ret, true);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       tree3->session->transport->oplock.handler = torture_oplock_handler;
+       tree3->session->transport->oplock.private_data = tree3;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH24: a open without level support and "
+                       "ask for a batch oplock\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                               SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       status = smb2_create(tree3, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h2 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "a 2nd open with level2 oplock support should "
+                       "generate a break\n");
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.handle.data[0], h2.data[0]);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree3, h2);
+       smb2_util_close(tree2, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_batch25(struct torture_context *tctx,
+                                    struct smb2_tree *tree1)
+{
+       const char *fname = BASEDIR "\\test_batch25.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "BATCH25: open a file with an batch oplock "
+                       "(share mode: none)\n");
+
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       torture_comment(tctx, "changing the file attribute info should trigger "
+                       "a break and a violation\n");
+
+       status = smb2_util_setatr(tree1, fname, FILE_ATTRIBUTE_HIDDEN);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, fname);
+       return ret;
+}
+
+/* Test how oplocks work on streams. */
+static bool test_raw_oplock_stream1(struct torture_context *tctx,
+                                   struct smb2_tree *tree1,
+                                   struct smb2_tree *tree2)
+{
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname_base = BASEDIR "\\test_stream1.txt";
+       const char *fname_stream, *fname_default_stream;
+       const char *default_stream = "::$DATA";
+       const char *stream = "Stream One:$DATA";
+       bool ret = true;
+       struct smb2_handle h, h_base, h_stream;
+       int i;
+
+#define NSTREAM_OPLOCK_RESULTS 8
+       struct {
+               const char **fname;
+               bool open_base_file;
+               uint32_t oplock_req;
+               uint32_t oplock_granted;
+       } stream_oplock_results[NSTREAM_OPLOCK_RESULTS] = {
+               /* Request oplock on stream without the base file open. */
+               {&fname_stream, false, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_BATCH},
+               {&fname_default_stream, false, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_BATCH},
+               {&fname_stream, false, SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_EXCLUSIVE},
+               {&fname_default_stream, false,  SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_EXCLUSIVE},
+
+               /* Request oplock on stream with the base file open. */
+               {&fname_stream, true, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_BATCH},
+               {&fname_default_stream, true, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_II},
+               {&fname_stream, true, SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_EXCLUSIVE},
+               {&fname_default_stream, true,  SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_II},
+       };
+
+       /* Only passes against windows at the moment. */
+       if (torture_setting_bool(tctx, "samba3", false) ||
+           torture_setting_bool(tctx, "samba4", false)) {
+               torture_skip(tctx, "STREAM1 disabled against samba3+4\n");
+       }
+
+       fname_stream = talloc_asprintf(tctx, "%s:%s", fname_base, stream);
+       fname_default_stream = talloc_asprintf(tctx, "%s%s", fname_base,
+                                              default_stream);
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* Initialize handles to "closed".  Using -1 in the first 64-bytes
+        * as the sentry for this */
+       h_stream.data[0] = -1;
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname_base);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       tree2->session->transport->oplock.handler = torture_oplock_handler;
+       tree2->session->transport->oplock.private_data = tree2;
+
+       /* Setup generic open parameters. */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = (SEC_FILE_READ_DATA |
+                                    SEC_FILE_WRITE_DATA |
+                                    SEC_FILE_APPEND_DATA |
+                                    SEC_STD_READ_CONTROL);
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                                 NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+
+       /* Create the file with a stream */
+       io.smb2.in.fname = fname_stream;
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error creating file");
+       smb2_util_close(tree1, io.smb2.out.file.handle);
+
+       /* Change the disposition to open now that the file has been created. */
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+
+       /* Try some permutations of taking oplocks on streams. */
+       for (i = 0; i < NSTREAM_OPLOCK_RESULTS; i++) {
+               const char *fname = *stream_oplock_results[i].fname;
+               bool open_base_file = stream_oplock_results[i].open_base_file;
+               uint32_t oplock_req = stream_oplock_results[i].oplock_req;
+               uint32_t oplock_granted =
+                   stream_oplock_results[i].oplock_granted;
+
+               if (open_base_file) {
+                       torture_comment(tctx, "Opening base file: %s with "
+                           "%d\n", fname_base, SMB2_OPLOCK_LEVEL_BATCH);
+                       io.smb2.in.fname = fname_base;
+                       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+                       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+                       status = smb2_create(tree2, tctx, &(io.smb2));
+                       torture_assert_ntstatus_ok(tctx, status,
+                           "Error opening file");
+                       CHECK_VAL(io.smb2.out.oplock_level,
+                           SMB2_OPLOCK_LEVEL_BATCH);
+                       h_base = io.smb2.out.file.handle;
+               }
+
+               torture_comment(tctx, "%d: Opening stream: %s with %d\n", i,
+                   fname, oplock_req);
+               io.smb2.in.fname = fname;
+               io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+               io.smb2.in.oplock_level = oplock_req;
+
+               /* Do the open with the desired oplock on the stream. */
+               status = smb2_create(tree1, tctx, &(io.smb2));
+               torture_assert_ntstatus_ok(tctx, status, "Error opening file");
+               CHECK_VAL(io.smb2.out.oplock_level, oplock_granted);
+               smb2_util_close(tree1, io.smb2.out.file.handle);
+
+               /* Cleanup the base file if it was opened. */
+               if (open_base_file)
+                       smb2_util_close(tree2, h_base);
+       }
+
+       /* Open the stream with an exclusive oplock. */
+       torture_comment(tctx, "Opening stream: %s with %d\n",
+           fname_stream, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+       io.smb2.in.fname = fname_stream;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening file");
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
+       h_stream = io.smb2.out.file.handle;
+
+       /* Open the base file and see if it contends. */
+       ZERO_STRUCT(break_info);
+       torture_comment(tctx, "Opening base file: %s with %d\n",
+           fname_base, SMB2_OPLOCK_LEVEL_BATCH);
+       io.smb2.in.fname = fname_base;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening file");
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+       smb2_util_close(tree2, io.smb2.out.file.handle);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       /* Open the stream again to see if it contends. */
+       ZERO_STRUCT(break_info);
+       torture_comment(tctx, "Opening stream again: %s with "
+           "%d\n", fname_base, SMB2_OPLOCK_LEVEL_BATCH);
+       io.smb2.in.fname = fname_stream;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening file");
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+       smb2_util_close(tree2, io.smb2.out.file.handle);
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+
+       /* Close the stream. */
+       if (h_stream.data[0] != -1) {
+               smb2_util_close(tree1, h_stream);
+       }
+
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+static bool test_smb2_oplock_doc(struct torture_context *tctx, struct smb2_tree *tree)
+{
+       const char *fname = BASEDIR "\\test_oplock_doc.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+
+       status = torture_smb2_testdir(tree, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree, fname);
+       tree->session->transport->oplock.handler = torture_oplock_handler;
+       tree->session->transport->oplock.private_data = tree;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "open a delete-on-close file with a batch "
+                       "oplock\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       status = smb2_create(tree, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       smb2_util_close(tree, h1);
+
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, BASEDIR);
+       return ret;
+}
+
+/* Open a file with a batch oplock, then open it again from a second client
+ * requesting no oplock. Having two open file handles should break our own
+ * oplock during BRL acquisition.
+ */
+static bool test_smb2_oplock_brl1(struct torture_context *tctx,
+                               struct smb2_tree *tree1,
+                               struct smb2_tree *tree2)
+{
+       const char *fname = BASEDIR "\\test_batch_brl.dat";
+       /*int fname, f;*/
+       bool ret = true;
+       uint8_t buf[1000];
+       bool correct = true;
+       union smb_open io;
+       NTSTATUS status;
+       struct smb2_lock lck;
+       struct smb2_lock_element lock[1];
+       struct smb2_handle h, h1, h2;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_two_notifications;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                                   SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                                 NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+         with a batch oplock we get a break
+       */
+       torture_comment(tctx, "open with batch oplock\n");
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       /* create a file with bogus data */
+       memset(buf, 0, sizeof(buf));
+
+       status = smb2_util_write(tree1, h1,buf, 0, sizeof(buf));
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
+               torture_comment(tctx, "Failed to create file\n");
+               correct = false;
+               goto done;
+       }
+
+       torture_comment(tctx, "a 2nd open should give a break\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = 0;
+       status = smb2_create(tree2, tctx, &(io.smb2));
+       h2 = io.smb2.out.file.handle;
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "a self BRL acquisition should break to none\n");
+       lock[0].offset = 0;
+       lock[0].length = 4;
+       lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
+                       SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
+
+       ZERO_STRUCT(lck);
+       lck.in.file.handle = h1;
+       lck.in.locks = &lock[0];
+       lck.in.lock_count = 1;
+       status = smb2_lock(tree1, &lck);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_NONE);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.failures, 0);
+
+       /* expect no oplock break */
+       ZERO_STRUCT(break_info);
+       lock[0].offset = 2;
+       status = smb2_lock(tree1, &lck);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_LOCK_NOT_GRANTED,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree2, h2);
+       smb2_util_close(tree1, h);
+
+done:
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+
+}
+
+/* Open a file with a batch oplock on one tree and then acquire a brl.
+ * We should not contend our own oplock.
+ */
+static bool test_smb2_oplock_brl2(struct torture_context *tctx, struct smb2_tree *tree1)
+{
+       const char *fname = BASEDIR "\\test_batch_brl.dat";
+       /*int fname, f;*/
+       bool ret = true;
+       uint8_t buf[1000];
+       bool correct = true;
+       union smb_open io;
+       NTSTATUS status;
+       struct smb2_handle h, h1;
+       struct smb2_lock lck;
+       struct smb2_lock_element lock[1];
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                                   SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                                 NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+         with a batch oplock we get a break
+       */
+       torture_comment(tctx, "open with batch oplock\n");
+       ZERO_STRUCT(break_info);
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       /* create a file with bogus data */
+       memset(buf, 0, sizeof(buf));
+
+       status = smb2_util_write(tree1, h1, buf, 0, sizeof(buf));
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
+               torture_comment(tctx, "Failed to create file\n");
+               correct = false;
+               goto done;
+       }
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "a self BRL acquisition should not break to "
+                       "none\n");
+
+       lock[0].offset = 0;
+       lock[0].length = 4;
+       lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
+                       SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
+
+       ZERO_STRUCT(lck);
+       lck.in.file.handle = h1;
+       lck.in.locks = &lock[0];
+       lck.in.lock_count = 1;
+       status = smb2_lock(tree1, &lck);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       lock[0].offset = 2;
+       status = smb2_lock(tree1, &lck);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_LOCK_NOT_GRANTED,
+                                     "Incorrect status");
+
+       /* With one file handle open a BRL should not contend our oplock.
+        * Thus, no oplock break will be received and the entire break_info
+        * struct will be 0 */
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+done:
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+/* Open a file with a batch oplock twice from one tree and then acquire a
+ * brl. BRL acquisition should break our own oplock.
+ */
+static bool test_smb2_oplock_brl3(struct torture_context *tctx, struct smb2_tree *tree1)
+{
+       const char *fname = BASEDIR "\\test_batch_brl.dat";
+       bool ret = true;
+       uint8_t buf[1000];
+       bool correct = true;
+       union smb_open io;
+       NTSTATUS status;
+       struct smb2_handle h, h1, h2;
+       struct smb2_lock lck;
+       struct smb2_lock_element lock[1];
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+       tree1->session->transport->oplock.handler =
+           torture_oplock_handler_two_notifications;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                                   SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                                 NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+         with a batch oplock we get a break
+       */
+       torture_comment(tctx, "open with batch oplock\n");
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
+
+       /* create a file with bogus data */
+       memset(buf, 0, sizeof(buf));
+       status = smb2_util_write(tree1, h1, buf, 0, sizeof(buf));
+
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
+               torture_comment(tctx, "Failed to create file\n");
+               correct = false;
+               goto done;
+       }
+
+       torture_comment(tctx, "a 2nd open should give a break\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = 0;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       h2 = io.smb2.out.file.handle;
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
+       CHECK_VAL(break_info.failures, 0);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "a self BRL acquisition should break to none\n");
+
+       lock[0].offset = 0;
+       lock[0].length = 4;
+       lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
+                       SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
+
+       ZERO_STRUCT(lck);
+       lck.in.file.handle = h1;
+       lck.in.locks = &lock[0];
+       lck.in.lock_count = 1;
+       status = smb2_lock(tree1, &lck);
+       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_NONE);
+       CHECK_VAL(break_info.handle.data[0], h1.data[0]);
+       CHECK_VAL(break_info.failures, 0);
+
+       /* expect no oplock break */
+       ZERO_STRUCT(break_info);
+       lock[0].offset = 2;
+       status = smb2_lock(tree1, &lck);
+       torture_assert_ntstatus_equal(tctx, status, NT_STATUS_LOCK_NOT_GRANTED,
+                                     "Incorrect status");
+
+       torture_wait_for_oplock_break(tctx);
+       CHECK_VAL(break_info.count, 0);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 0);
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h2);
+       smb2_util_close(tree1, h);
+
+done:
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+
+}
+
+/* Starting the SMB2 specific oplock tests at 500 so we can keep the SMB1
+ * tests in sync with an identically numbered SMB2 test */
+
+/* Test whether the server correctly returns an error when we send
+ * a response to a levelII to none oplock notification. */
+static bool test_smb2_oplock_levelII500(struct torture_context *tctx,
+                                     struct smb2_tree *tree1)
+{
+       const char *fname = BASEDIR "\\test_levelII500.dat";
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+       struct smb2_handle h, h1;
+       char c = 0;
+
+       status = torture_smb2_testdir(tree1, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       /* cleanup */
+       smb2_util_unlink(tree1, fname);
+
+       tree1->session->transport->oplock.handler = torture_oplock_handler;
+       tree1->session->transport->oplock.private_data = tree1;
+
+       /*
+         base ntcreatex parms
+       */
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       torture_comment(tctx, "LEVELII500: acknowledging a break from II to "
+                       "none should return an error\n");
+       ZERO_STRUCT(break_info);
+
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
+                               SEC_RIGHTS_FILE_WRITE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE;
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_II;
+       status = smb2_create(tree1, tctx, &(io.smb2));
+       torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
+       h1 = io.smb2.out.file.handle;
+       CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
+
+       ZERO_STRUCT(break_info);
+
+       torture_comment(tctx, "write should trigger a break to none and when "
+                       "we reply, an oplock break failure\n");
+       smb2_util_write(tree1, h1, &c, 0, 1);
+
+       /* Wait several times to receive both the break notification, and the
+        * NT_STATUS_INVALID_OPLOCK_PROTOCOL error in the break response */
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+       torture_wait_for_oplock_break(tctx);
+
+       /* There appears to be a race condition in W2K8 and W2K8R2 where
+        * sometimes the server will happily reply to our break response with
+        * NT_STATUS_OK, and sometimes it will return the OPLOCK_PROTOCOL
+        * error.  As the MS-SMB2 doc states that a client should not reply to
+        * a level2 to none break notification, I'm leaving the protocol error
+        * as the expected behavior. */
+       CHECK_VAL(break_info.count, 1);
+       CHECK_VAL(break_info.level, 0);
+       CHECK_VAL(break_info.failures, 1);
+       torture_assert_ntstatus_equal(tctx, break_info.failure_status,
+                                     NT_STATUS_INVALID_OPLOCK_PROTOCOL,
+                                     "Incorrect status");
+
+       smb2_util_close(tree1, h1);
+       smb2_util_close(tree1, h);
+
+       smb2_deltree(tree1, BASEDIR);
+       return ret;
+}
+
+struct torture_suite *torture_smb2_oplocks_init(void)
+{
+       struct torture_suite *suite =
+           torture_suite_create(talloc_autofree_context(), "OPLOCK");
+
+       torture_suite_add_2smb2_test(suite, "EXCLUSIVE1", test_smb2_oplock_exclusive1);
+       torture_suite_add_2smb2_test(suite, "EXCLUSIVE2", test_smb2_oplock_exclusive2);
+       torture_suite_add_2smb2_test(suite, "EXCLUSIVE3", test_smb2_oplock_exclusive3);
+       torture_suite_add_2smb2_test(suite, "EXCLUSIVE4", test_smb2_oplock_exclusive4);
+       torture_suite_add_2smb2_test(suite, "EXCLUSIVE5", test_smb2_oplock_exclusive5);
+       torture_suite_add_2smb2_test(suite, "EXCLUSIVE6", test_smb2_oplock_exclusive6);
+       torture_suite_add_2smb2_test(suite, "BATCH1", test_smb2_oplock_batch1);
+       torture_suite_add_2smb2_test(suite, "BATCH2", test_smb2_oplock_batch2);
+       torture_suite_add_2smb2_test(suite, "BATCH3", test_smb2_oplock_batch3);
+       torture_suite_add_2smb2_test(suite, "BATCH4", test_smb2_oplock_batch4);
+       torture_suite_add_2smb2_test(suite, "BATCH5", test_smb2_oplock_batch5);
+       torture_suite_add_2smb2_test(suite, "BATCH6", test_smb2_oplock_batch6);
+       torture_suite_add_2smb2_test(suite, "BATCH7", test_smb2_oplock_batch7);
+       torture_suite_add_2smb2_test(suite, "BATCH8", test_smb2_oplock_batch8);
+       torture_suite_add_2smb2_test(suite, "BATCH9", test_smb2_oplock_batch9);
+       torture_suite_add_2smb2_test(suite, "BATCH10", test_smb2_oplock_batch10);
+       torture_suite_add_2smb2_test(suite, "BATCH11", test_smb2_oplock_batch11);
+       torture_suite_add_2smb2_test(suite, "BATCH12", test_smb2_oplock_batch12);
+       torture_suite_add_2smb2_test(suite, "BATCH13", test_smb2_oplock_batch13);
+       torture_suite_add_2smb2_test(suite, "BATCH14", test_smb2_oplock_batch14);
+       torture_suite_add_2smb2_test(suite, "BATCH15", test_smb2_oplock_batch15);
+       torture_suite_add_2smb2_test(suite, "BATCH16", test_smb2_oplock_batch16);
+       torture_suite_add_1smb2_test(suite, "BATCH19", test_smb2_oplock_batch19);
+       torture_suite_add_2smb2_test(suite, "BATCH20", test_smb2_oplock_batch20);
+       torture_suite_add_1smb2_test(suite, "BATCH21", test_smb2_oplock_batch21);
+       torture_suite_add_1smb2_test(suite, "BATCH22", test_smb2_oplock_batch22);
+       torture_suite_add_2smb2_test(suite, "BATCH23", test_smb2_oplock_batch23);
+       torture_suite_add_2smb2_test(suite, "BATCH24", test_smb2_oplock_batch24);
+       torture_suite_add_1smb2_test(suite, "BATCH25", test_smb2_oplock_batch25);
+       torture_suite_add_2smb2_test(suite, "STREAM1", test_raw_oplock_stream1);
+       torture_suite_add_1smb2_test(suite, "DOC", test_smb2_oplock_doc);
+       torture_suite_add_2smb2_test(suite, "BRL1", test_smb2_oplock_brl1);
+       torture_suite_add_1smb2_test(suite, "BRL2", test_smb2_oplock_brl2);
+       torture_suite_add_1smb2_test(suite, "BRL3", test_smb2_oplock_brl3);
+       torture_suite_add_1smb2_test(suite, "LEVELII500", test_smb2_oplock_levelII500);
+
+       suite->description = talloc_strdup(suite, "SMB2-OPLOCK tests");
+
+       return suite;
+}
+
+/*
+   stress testing of oplocks
+*/
+bool test_smb2_bench_oplock(struct torture_context *tctx,
+                                  struct smb2_tree *tree)
+{
+       struct smb2_tree **trees;
+       bool ret = true;
+       NTSTATUS status;
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
+       int i, count=0;
+       int timelimit = torture_setting_int(tctx, "timelimit", 10);
+       union smb_open io;
+       struct timeval tv;
+       struct smb2_handle h;
+
+       trees = talloc_array(mem_ctx, struct smb2_tree *, torture_nprocs);
+
+       torture_comment(tctx, "Opening %d connections\n", torture_nprocs);
+       for (i=0;i<torture_nprocs;i++) {
+               if (!torture_smb2_connection(tctx, &trees[i])) {
+                       return false;
+               }
+               talloc_steal(mem_ctx, trees[i]);
+               trees[i]->session->transport->oplock.handler =
+                                       torture_oplock_handler_close;
+               trees[i]->session->transport->oplock.private_data = trees[i];
+       }
+
+       status = torture_smb2_testdir(trees[0], BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.level = RAW_OPEN_SMB2;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = BASEDIR "\\test.dat";
+       io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+       io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+       tv = timeval_current();
+
+       /*
+         we open the same file with SHARE_ACCESS_NONE from all the
+         connections in a round robin fashion. Each open causes an
+         oplock break on the previous connection, which is answered
+         by the oplock_handler_close() to close the file.
+
+         This measures how fast we can pass on oplocks, and stresses
+         the oplock handling code
+       */
+       torture_comment(tctx, "Running for %d seconds\n", timelimit);
+       while (timeval_elapsed(&tv) < timelimit) {
+               for (i=0;i<torture_nprocs;i++) {
+                       NTSTATUS status;
+
+                       status = smb2_create(trees[i], mem_ctx, &(io.smb2));
+                       torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
+                       count++;
+               }
+
+               if (torture_setting_bool(tctx, "progress", true)) {
+                       torture_comment(tctx, "%.2f ops/second\r",
+                                       count/timeval_elapsed(&tv));
+               }
+       }
+
+       torture_comment(tctx, "%.2f ops/second\n", count/timeval_elapsed(&tv));
+       smb2_util_close(trees[0], io.smb2.out.file.handle);
+       smb2_util_unlink(trees[0], BASEDIR "\\test.dat");
+       smb2_deltree(trees[0], BASEDIR);
+       talloc_free(mem_ctx);
+       return ret;
+}
+
+static struct hold_oplock_info {
+       const char *fname;
+       bool close_on_break;
+       uint32_t share_access;
+       struct smb2_handle handle;
+} hold_info[] = {
+       { BASEDIR "\\notshared_close", true,
+         NTCREATEX_SHARE_ACCESS_NONE, },
+       { BASEDIR "\\notshared_noclose", false,
+         NTCREATEX_SHARE_ACCESS_NONE, },
+       { BASEDIR "\\shared_close", true,
+         NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE, },
+       { BASEDIR "\\shared_noclose", false,
+         NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE, },
+};
+
+static bool torture_oplock_handler_hold(struct smb2_transport *transport,
+                                       const struct smb2_handle *handle,
+                                       uint8_t level, void *private_data)
+{
+       struct hold_oplock_info *info;
+       int i;
+
+       for (i=0;i<ARRAY_SIZE(hold_info);i++) {
+               if (smb2_util_handle_equal(hold_info[i].handle, *handle))
+                       break;
+       }
+
+       if (i == ARRAY_SIZE(hold_info)) {
+               printf("oplock break for unknown handle 0x%llx%llx\n",
+                      handle->data[0], handle->data[1]);
+               return false;
+       }
+
+       info = &hold_info[i];
+
+       if (info->close_on_break) {
+               printf("oplock break on %s - closing\n", info->fname);
+               torture_oplock_handler_close(transport, handle,
+                                            level, private_data);
+               return true;
+       }
+
+       printf("oplock break on %s - acking break\n", info->fname);
+       printf("Acking to none in oplock handler\n");
+
+       torture_oplock_handler_ack_to_none(transport, handle,
+                                          level, private_data);
+       return true;
+}
+
+/*
+   used for manual testing of oplocks - especially interaction with
+   other filesystems (such as NFS and local access)
+*/
+bool test_smb2_hold_oplock(struct torture_context *tctx,
+                          struct smb2_tree *tree)
+{
+       struct torture_context *mem_ctx = talloc_new(tctx);
+       struct tevent_context *ev =
+               (struct tevent_context *)tree->session->transport->socket->event.ctx;
+       int i;
+       struct smb2_handle h;
+       NTSTATUS status;
+
+       torture_comment(tctx, "Setting up open files with oplocks in %s\n",
+                       BASEDIR);
+
+       status = torture_smb2_testdir(tree, BASEDIR, &h);
+       torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
+
+       tree->session->transport->oplock.handler = torture_oplock_handler_hold;
+       tree->session->transport->oplock.private_data = tree;
+
+       /* setup the files */
+       for (i=0;i<ARRAY_SIZE(hold_info);i++) {
+               union smb_open io;
+               NTSTATUS status;
+               char c = 1;
+
+               ZERO_STRUCT(io.smb2);
+               io.generic.level = RAW_OPEN_SMB2;
+               io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+               io.smb2.in.alloc_size = 0;
+               io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+               io.smb2.in.share_access = hold_info[i].share_access;
+               io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+               io.smb2.in.create_options = 0;
+               io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+               io.smb2.in.security_flags = 0;
+               io.smb2.in.fname = hold_info[i].fname;
+               io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
+               io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
+
+               torture_comment(tctx, "opening %s\n", hold_info[i].fname);
+
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               if (!NT_STATUS_IS_OK(status)) {
+                       torture_comment(tctx, "Failed to open %s - %s\n",
+                              hold_info[i].fname, nt_errstr(status));
+                       return false;
+               }
+
+               if (io.smb2.out.oplock_level != SMB2_OPLOCK_LEVEL_BATCH) {
+                       torture_comment(tctx, "Oplock not granted for %s - "
+                                       "expected %d but got %d\n",
+                                       hold_info[i].fname,
+                                       SMB2_OPLOCK_LEVEL_BATCH,
+                                       io.smb2.out.oplock_level);
+                       return false;
+               }
+               hold_info[i].handle = io.smb2.out.file.handle;
+
+               /* make the file non-zero size */
+               status = smb2_util_write(tree, hold_info[i].handle, &c, 0, 1);
+               if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
+                       torture_comment(tctx, "Failed to write to file\n");
+                       return false;
+               }
+       }
+
+       torture_comment(tctx, "Waiting for oplock events\n");
+       event_loop_wait(ev);
+       smb2_deltree(tree, BASEDIR);
+       talloc_free(mem_ctx);
+       return true;
+}

diff --git a/source4/torture/smb2/oplocks.c b/source4/torture/smb2/oplocks.c
deleted file mode 100644 (file)
index 3fee0b4..0000000
--- a/source4/torture/smb2/oplocks.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-
-   test suite for SMB2 oplocks
-
-   Copyright (C) Stefan Metzmacher 2008
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "librpc/gen_ndr/security.h"
-#include "libcli/smb2/smb2.h"
-#include "libcli/smb2/smb2_calls.h"
-#include "torture/torture.h"
-#include "torture/smb2/proto.h"
-
-#define CHECK_VAL(v, correct) do { \
-       if ((v) != (correct)) { \
-               torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%x - should be 0x%x\n", \
-                               __location__, #v, (int)v, (int)correct); \
-               ret = false; \
-       }} while (0)
-
-#define CHECK_STATUS(status, correct) do { \
-       if (!NT_STATUS_EQUAL(status, correct)) { \
-               torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
-                      nt_errstr(status), nt_errstr(correct)); \
-               ret = false; \
-               goto done; \
-       }} while (0)
-
-static struct {
-       struct smb2_handle handle;
-       uint8_t level;
-       struct smb2_break br;
-       int count;
-       int failures;
-} break_info;
-
-static void torture_oplock_break_callback(struct smb2_request *req)
-{
-       NTSTATUS status;
-       struct smb2_break br;
-
-       ZERO_STRUCT(br);
-       status = smb2_break_recv(req, &break_info.br);
-       if (!NT_STATUS_IS_OK(status)) {
-               break_info.failures++;
-       }
-
-       return;
-}
-
-/* a oplock break request handler */
-static bool torture_oplock_handler(struct smb2_transport *transport,
-                                  const struct smb2_handle *handle,
-                                  uint8_t level, void *private_data)
-{
-       struct smb2_tree *tree = private_data;
-       const char *name;
-       struct smb2_request *req;
-
-       break_info.handle       = *handle;
-       break_info.level        = level;
-       break_info.count++;
-
-       switch (level) {
-       case SMB2_OPLOCK_LEVEL_II:
-               name = "level II";
-               break;
-       case SMB2_OPLOCK_LEVEL_NONE:
-               name = "none";
-               break;
-       default:
-               name = "unknown";
-               break_info.failures++;
-       }
-       printf("Acking to %s [0x%02X] in oplock handler\n",
-               name, level);
-
-       ZERO_STRUCT(break_info.br);
-       break_info.br.in.file.handle    = *handle;
-       break_info.br.in.oplock_level   = level;
-       break_info.br.in.reserved       = 0;
-       break_info.br.in.reserved2      = 0;
-
-       req = smb2_break_send(tree, &break_info.br);
-       req->async.fn = torture_oplock_break_callback;
-       req->async.private_data = NULL;
-
-       return true;
-}
-
-bool torture_smb2_oplock_batch1(struct torture_context *tctx,
-                               struct smb2_tree *tree)
-{
-       TALLOC_CTX *mem_ctx = talloc_new(tctx);
-       struct smb2_handle h1, h2;
-       struct smb2_create io;
-       NTSTATUS status;
-       const char *fname = "oplock.dat";
-       bool ret = true;
-
-       tree->session->transport->oplock.handler        = torture_oplock_handler;
-       tree->session->transport->oplock.private_data   = tree;
-
-       smb2_util_unlink(tree, fname);
-
-       ZERO_STRUCT(break_info);
-
-       ZERO_STRUCT(io);
-       io.in.security_flags            = 0x00;
-       io.in.oplock_level              = SMB2_OPLOCK_LEVEL_BATCH;
-       io.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
-       io.in.create_flags              = 0x00000000;
-       io.in.reserved                  = 0x00000000;
-       io.in.desired_access            = SEC_RIGHTS_FILE_ALL;
-       io.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
-       io.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
-                                         NTCREATEX_SHARE_ACCESS_WRITE |
-                                         NTCREATEX_SHARE_ACCESS_DELETE;
-       io.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
-       io.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
-                                         NTCREATEX_OPTIONS_ASYNC_ALERT |
-                                         NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
-                                         0x00200000;
-       io.in.fname                     = fname;
-
-       status = smb2_create(tree, mem_ctx, &io);
-       CHECK_STATUS(status, NT_STATUS_OK);
-       CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
-       /*CHECK_VAL(io.out.reserved, 0);*/
-       CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_CREATED);
-       CHECK_VAL(io.out.alloc_size, 0);
-       CHECK_VAL(io.out.size, 0);
-       CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
-       CHECK_VAL(io.out.reserved2, 0);
-       CHECK_VAL(break_info.count, 0);
-
-       h1 = io.out.file.handle;
-
-       ZERO_STRUCT(io.in.blobs);
-       status = smb2_create(tree, mem_ctx, &io);
-       CHECK_VAL(break_info.count, 1);
-       CHECK_VAL(break_info.failures, 0);
-       CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
-       CHECK_STATUS(status, NT_STATUS_OK);
-       CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
-       /*CHECK_VAL(io.out.reserved, 0);*/
-       CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
-       CHECK_VAL(io.out.alloc_size, 0);
-       CHECK_VAL(io.out.size, 0);
-       CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
-       CHECK_VAL(io.out.reserved2, 0);
-
-       h2 = io.out.file.handle;
-
-done:
-       talloc_free(mem_ctx);
-
-       smb2_util_close(tree, h1);
-       smb2_util_close(tree, h2);
-       smb2_util_unlink(tree, fname);
-       return ret;
-}

diff --git a/source4/torture/smb2/smb2.c b/source4/torture/smb2/smb2.c
index 4a3ca1465d61c865cdc70b6752732b386b9d046f..f1d8fbb81490a991ecad17cec62e4a6794034d9d 100644 (file)
--- a/source4/torture/smb2/smb2.c
+++ b/source4/torture/smb2/smb2.c
@@ -139,10 +139,13 @@ NTSTATUS torture_smb2_init(void)
        torture_suite_add_suite(suite, torture_smb2_create_init());
        torture_suite_add_simple_test(suite, "NOTIFY", torture_smb2_notify);
        torture_suite_add_suite(suite, torture_smb2_durable_open_init());
-       torture_suite_add_1smb2_test(suite, "OPLOCK-BATCH1", torture_smb2_oplock_batch1);
        torture_suite_add_suite(suite, torture_smb2_dir_init());
        torture_suite_add_suite(suite, torture_smb2_lease_init());
        torture_suite_add_suite(suite, torture_smb2_compound_init());
+       torture_suite_add_suite(suite, torture_smb2_oplocks_init());
+       torture_suite_add_suite(suite, torture_smb2_streams_init());
+       torture_suite_add_1smb2_test(suite, "BENCH-OPLOCK", test_smb2_bench_oplock);
+       torture_suite_add_1smb2_test(suite, "HOLD-OPLOCK", test_smb2_hold_oplock);
 
        suite->description = talloc_strdup(suite, "SMB2-specific tests");
 

diff --git a/source4/torture/smb2/streams.c b/source4/torture/smb2/streams.c
new file mode 100644 (file)
index 0000000..f186a54
--- /dev/null
+++ b/source4/torture/smb2/streams.c
@@ -0,0 +1,1768 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   test alternate data streams
+
+   Copyright (C) Andrew Tridgell 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/>.
+*/
+
+#include "includes.h"
+#include "libcli/smb2/smb2.h"
+#include "libcli/smb2/smb2_calls.h"
+#include "libcli/smb_composite/smb_composite.h"
+#include "libcli/raw/libcliraw.h"
+#include "libcli/raw/raw_proto.h"
+#include "libcli/libcli.h"
+
+#include "torture/torture.h"
+#include "torture/smb2/proto.h"
+#include "torture/util.h"
+
+#include "system/filesys.h"
+#include "system/locale.h"
+
+#define DNAME "teststreams"
+
+#define CHECK_STATUS(status, correct) do { \
+       if (!NT_STATUS_EQUAL(status, correct)) { \
+               torture_result(tctx, TORTURE_FAIL, \
+                   "(%s) Incorrect status %s - should be %s\n", \
+                   __location__, nt_errstr(status), nt_errstr(correct)); \
+               ret = false; \
+               goto done; \
+       }} while (0)
+
+#define CHECK_VALUE(v, correct) do { \
+       if ((v) != (correct)) { \
+               torture_result(tctx, TORTURE_FAIL, \
+                   "(%s) Incorrect value %s=%d - should be %d\n", \
+                   __location__, #v, (int)v, (int)correct); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_NTTIME(v, correct) do { \
+       if ((v) != (correct)) { \
+               torture_result(tctx, TORTURE_FAIL, \
+                   "(%s) Incorrect value %s=%llu - should be %llu\n", \
+                   __location__, #v, (unsigned long long)v, \
+                   (unsigned long long)correct); \
+               ret = false; \
+       }} while (0)
+
+#define CHECK_STR(v, correct) do { \
+       bool ok; \
+       if ((v) && !(correct)) { \
+               ok = false; \
+       } else if (!(v) && (correct)) { \
+               ok = false; \
+       } else if (!(v) && !(correct)) { \
+               ok = true; \
+       } else if (strcmp((v), (correct)) == 0) { \
+               ok = true; \
+       } else { \
+               ok = false; \
+       } \
+       if (!ok) { \
+               torture_comment(tctx,"(%s) Incorrect value %s='%s' - " \
+                   "should be '%s'\n", \
+                   __location__, #v, (v)?(v):"NULL", \
+                   (correct)?(correct):"NULL"); \
+               ret = false; \
+       }} while (0)
+
+
+static int qsort_string(const void *v1,
+                       const void *v2)
+{
+       char * const *s1 = v1;
+       char * const *s2 = v2;
+       return strcmp(*s1, *s2);
+}
+
+static int qsort_stream(const void *v1,
+                       const void *v2)
+{
+       const struct stream_struct * s1 = v1;
+       const struct stream_struct * s2 = v2;
+       return strcmp(s1->stream_name.s, s2->stream_name.s);
+}
+
+static bool check_stream(struct smb2_tree *tree,
+                        const char *location,
+                        TALLOC_CTX *mem_ctx,
+                        const char *fname,
+                        const char *sname,
+                        const char *value)
+{
+       struct smb2_handle handle;
+       struct smb2_create create;
+       struct smb2_read r;
+       NTSTATUS status;
+       const char *full_name;
+
+       full_name = talloc_asprintf(mem_ctx, "%s:%s", fname, sname);
+
+       ZERO_STRUCT(create);
+       create.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       create.in.create_disposition = NTCREATEX_DISP_OPEN;
+       create.in.fname = full_name;
+
+       status = smb2_create(tree, mem_ctx, &create);
+       if (!NT_STATUS_IS_OK(status)) {
+               if (value == NULL) {
+                       return true;
+               } else {
+                       torture_comment(mem_ctx, "Unable to open stream %s\n",
+                           full_name);
+                       return false;
+               }
+       }
+
+       handle = create.out.file.handle;
+       if (value == NULL) {
+               return true;
+       }
+
+
+       ZERO_STRUCT(r);
+       r.in.file.handle = handle;
+       r.in.length      = strlen(value)+11;
+       r.in.offset      = 0;
+
+       status = smb2_read(tree, tree, &r);
+
+       if (!NT_STATUS_IS_OK(status)) {
+               torture_comment(mem_ctx, "(%s) Failed to read %lu bytes from "
+                   "stream '%s'\n", location, (long)strlen(value), full_name);
+               return false;
+       }
+
+       if (memcmp(r.out.data.data, value, strlen(value)) != 0) {
+               torture_comment(mem_ctx, "(%s) Bad data in stream\n", location);
+               return false;
+       }
+
+       smb2_util_close(tree, handle);
+       return true;
+}
+
+static bool check_stream_list(struct smb2_tree *tree,
+                             struct torture_context *tctx,
+                             const char *fname,
+                             int num_exp,
+                             const char **exp,
+                             struct smb2_handle h)
+{
+       union smb_fileinfo finfo;
+       NTSTATUS status;
+       int i;
+       TALLOC_CTX *tmp_ctx = talloc_new(tctx);
+       char **exp_sort;
+       struct stream_struct *stream_sort;
+       bool ret = false;
+
+       finfo.generic.level = RAW_FILEINFO_STREAM_INFORMATION;
+       finfo.generic.in.file.handle = h;
+
+       status = smb2_getinfo_file(tree, tctx, &finfo);
+       if (!NT_STATUS_IS_OK(status)) {
+               torture_comment(tctx, "(%s) smb_raw_pathinfo failed: %s\n",
+                   __location__, nt_errstr(status));
+               goto fail;
+       }
+
+       if (finfo.stream_info.out.num_streams != num_exp) {
+               torture_comment(tctx, "(%s) expected %d streams, got %d\n",
+                   __location__, num_exp, finfo.stream_info.out.num_streams);
+               goto fail;
+       }
+
+       if (num_exp == 0) {
+               ret = true;
+               goto fail;
+       }
+
+       exp_sort = talloc_memdup(tmp_ctx, exp, num_exp * sizeof(*exp));
+
+       if (exp_sort == NULL) {
+               goto fail;
+       }
+
+       qsort(exp_sort, num_exp, sizeof(*exp_sort), qsort_string);
+
+       stream_sort = talloc_memdup(tmp_ctx, finfo.stream_info.out.streams,
+                                   finfo.stream_info.out.num_streams *
+                                   sizeof(*stream_sort));
+
+       if (stream_sort == NULL) {
+               goto fail;
+       }
+
+       qsort(stream_sort, finfo.stream_info.out.num_streams,
+             sizeof(*stream_sort), qsort_stream);
+
+       for (i=0; i<num_exp; i++) {
+               if (strcmp(exp_sort[i], stream_sort[i].stream_name.s) != 0) {
+                       torture_comment(tctx,
+                           "(%s) expected stream name %s, got %s\n",
+                           __location__, exp_sort[i],
+                           stream_sort[i].stream_name.s);
+                       goto fail;
+               }
+       }
+
+       ret = true;
+ fail:
+       talloc_free(tmp_ctx);
+       return ret;
+}
+
+
+static bool test_stream_dir(struct torture_context *tctx,
+                           struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream.txt";
+       const char *sname1;
+       bool ret = true;
+       const char *basedir_data;
+       struct smb2_handle h;
+
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       basedir_data = talloc_asprintf(mem_ctx, "%s::$DATA", DNAME);
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
+       torture_comment(tctx, "%s\n", sname1);
+
+       torture_comment(tctx, "(%s) opening non-existant directory stream\n",
+           __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.file_attributes   = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+       io.smb2.in.create_flags = 0;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_NOT_A_DIRECTORY);
+
+       torture_comment(tctx, "(%s) opening basedir  stream\n", __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = basedir_data;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_NOT_A_DIRECTORY);
+
+       torture_comment(tctx, "(%s) opening basedir ::$DATA stream\n",
+           __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0x10;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = 0;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = basedir_data;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_FILE_IS_A_DIRECTORY);
+
+       torture_comment(tctx, "(%s) list the streams on the basedir\n",
+           __location__);
+       ret &= check_stream_list(tree, mem_ctx, DNAME, 0, NULL, h);
+done:
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+static bool test_stream_io(struct torture_context *tctx,
+                          struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream.txt";
+       const char *sname1, *sname2;
+       bool ret = true;
+       struct smb2_handle h, h2;
+
+       const char *one[] = { "::$DATA" };
+       const char *two[] = { "::$DATA", ":Second Stream:$DATA" };
+       const char *three[] = { "::$DATA", ":Stream One:$DATA",
+                               ":Second Stream:$DATA" };
+
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
+       sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname,
+                                "Second Stream");
+
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       torture_comment(tctx, "(%s) creating a stream on a non-existant file\n",
+               __location__);
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Stream One", NULL);
+
+       torture_comment(tctx, "(%s) check that open of base file is allowed\n", __location__);
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.fname = fname;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       torture_comment(tctx, "(%s) writing to stream\n", __location__);
+       status = smb2_util_write(tree, h2, "test data", 0, 9);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, h2);
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Stream One", "test data");
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.fname = sname1;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+
+       torture_comment(tctx, "(%s) modifying stream\n", __location__);
+       status = smb2_util_write(tree, h2, "MORE DATA ", 5, 10);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, h2);
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Stream One:$FOO", NULL);
+
+       torture_comment(tctx, "(%s) creating a stream2 on a existing file\n",
+           __location__);
+       io.smb2.in.fname = sname2;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+
+       torture_comment(tctx, "(%s) modifying stream\n", __location__);
+       status= smb2_util_write(tree, h2, "SECOND STREAM", 0, 13);
+       CHECK_STATUS(status, NT_STATUS_OK);
+       smb2_util_close(tree, h2);
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                            "Stream One", "test MORE DATA ");
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Stream One:$DATA", "test MORE DATA ");
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Stream One:", NULL);
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Second Stream", "SECOND STREAM");
+
+       if (!torture_setting_bool(tctx, "samba4", false)) {
+               ret &= check_stream(tree, __location__, mem_ctx, fname,
+                                   "SECOND STREAM:$DATA", "SECOND STREAM");
+       }
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Second Stream:$DATA", "SECOND STREAM");
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Second Stream:", NULL);
+
+       ret &= check_stream(tree, __location__, mem_ctx, fname,
+                           "Second Stream:$FOO", NULL);
+
+       io.smb2.in.fname = sname2;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+       check_stream_list(tree, tctx, fname, 3, three, h2);
+
+       smb2_util_close(tree, h2);
+
+       torture_comment(tctx, "(%s) deleting stream\n", __location__);
+       status = smb2_util_unlink(tree, sname1);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       io.smb2.in.fname = sname2;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+       check_stream_list(tree, tctx, fname, 2, two, h2);
+       smb2_util_close(tree, h2);
+
+       torture_comment(tctx, "(%s) delete a stream via delete-on-close\n",
+           __location__);
+       io.smb2.in.fname = sname2;
+       io.smb2.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+
+       smb2_util_close(tree, h2);
+       status = smb2_util_unlink(tree, sname2);
+       CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
+
+       io.smb2.in.fname = fname;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       h2 = io.smb2.out.file.handle;
+       check_stream_list(tree,tctx, fname, 1, one, h2);
+       smb2_util_close(tree, h2);
+
+       if (!torture_setting_bool(tctx, "samba4", false)) {
+               io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+               io.smb2.in.fname = sname1;
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               CHECK_STATUS(status, NT_STATUS_OK);
+               smb2_util_close(tree, io.ntcreatex.out.file.handle);
+               io.smb2.in.fname = sname2;
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               CHECK_STATUS(status, NT_STATUS_OK);
+               smb2_util_close(tree, io.ntcreatex.out.file.handle);
+       }
+
+       torture_comment(tctx, "(%s) deleting file\n", __location__);
+       status = smb2_util_unlink(tree, fname);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+done:
+       smb2_util_close(tree, h2);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+/*
+  test stream sharemodes
+*/
+static bool test_stream_sharemodes(struct torture_context *tctx,
+                                  struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream_share.txt";
+       const char *sname1, *sname2;
+       bool ret = true;
+       struct smb2_handle h, h1, h2;
+
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
+       sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname,
+                                "Second Stream");
+
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       torture_comment(tctx, "(%s) Testing stream share mode conflicts\n",
+           __location__);
+       ZERO_STRUCT(io.smb2);
+       io.generic.level = RAW_OPEN_SMB2;
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       /*
+        * A different stream does not give a sharing violation
+        */
+
+       io.smb2.in.fname = sname2;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+
+       /*
+        * ... whereas the same stream does with unchanged access/share_access
+        * flags
+        */
+
+       io.smb2.in.fname = sname1;
+       io.smb2.in.create_disposition = 0;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+       io.smb2.in.fname = sname2;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+done:
+       smb2_util_close(tree, h1);
+       smb2_util_close(tree, h2);
+       status = smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+/*
+ *  Test FILE_SHARE_DELETE on streams
+ *
+ * A stream opened with !FILE_SHARE_DELETE prevents the main file to be opened
+ * with SEC_STD_DELETE.
+ *
+ * The main file opened with !FILE_SHARE_DELETE does *not* prevent a stream to
+ * be opened with SEC_STD_DELETE.
+ *
+ * A stream held open with FILE_SHARE_DELETE allows the file to be
+ * deleted. After the main file is deleted, access to the open file descriptor
+ * still works, but all name-based access to both the main file as well as the
+ * stream is denied with DELETE pending.
+ *
+ * This means, an open of the main file with SEC_STD_DELETE should walk all
+ * streams and also open them with SEC_STD_DELETE. If any of these opens gives
+ * SHARING_VIOLATION, the main open fails.
+ *
+ * Closing the main file after delete_on_close has been set does not really
+ * unlink it but leaves the corresponding share mode entry with
+ * delete_on_close being set around until all streams are closed.
+ *
+ * Opening a stream must also look at the main file's share mode entry, look
+ * at the delete_on_close bit and potentially return DELETE_PENDING.
+ */
+
+static bool test_stream_delete(struct torture_context *tctx,
+                              struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream_delete.txt";
+       const char *sname1;
+       bool ret = true;
+       struct smb2_handle h, h1;
+       struct smb2_read r;
+
+       if (!torture_setting_bool(tctx, "samba4", true)) {
+               torture_comment(tctx, "Skipping test as samba4 is enabled\n");
+               goto done;
+       }
+
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
+
+       /* clean slate .. */
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       torture_comment(tctx, "(%s) opening non-existant file stream\n",
+           __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       status = smb2_util_write(tree, h1, "test data", 0, 9);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       /*
+        * One stream opened without FILE_SHARE_DELETE prevents the main file
+        * to be deleted or even opened with DELETE access
+        */
+
+       status = smb2_util_unlink(tree, fname);
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.fname = fname;
+       io.smb2.in.desired_access = SEC_STD_DELETE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+       smb2_util_close(tree, h1);
+
+       /*
+        * ... but unlink works if a stream is opened with FILE_SHARE_DELETE
+        */
+
+       io.smb2.in.fname = sname1;
+       io.smb2.in.desired_access = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
+                       NTCREATEX_SHARE_ACCESS_READ |
+                       NTCREATEX_SHARE_ACCESS_WRITE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       status = smb2_util_unlink(tree, fname);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       /*
+        * file access still works on the stream while the main file is closed
+        */
+       ZERO_STRUCT(r);
+       r.in.file.handle = h1;
+       r.in.length      = 9;
+       r.in.offset      = 0;
+
+       status = smb2_read(tree, tree, &r);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       /*
+        * name-based access to both the main file and the stream does not
+        * work anymore but gives DELETE_PENDING
+        */
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.fname = fname;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
+
+       /*
+        * older S3 doesn't do this
+        */
+
+       io.smb2.in.fname = sname1;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
+
+       smb2_util_close(tree, h1);
+
+       /*
+        * After closing the stream the file is really gone.
+        */
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.fname = fname;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
+
+done:
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+/*
+  test stream names
+*/
+static bool test_stream_names(struct torture_context *tctx,
+                             struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       union smb_fileinfo finfo;
+       union smb_fileinfo stinfo;
+       union smb_setfileinfo sinfo;
+       const char *fname = DNAME "\\stream_names.txt";
+       const char *sname1, *sname1b, *sname1c, *sname1d;
+       const char *sname2, *snamew, *snamew2;
+       const char *snamer1, *snamer2;
+       bool ret = true;
+       struct smb2_handle h, h1, h2, h3;
+       int i;
+       const char *four[4] = {
+               "::$DATA",
+               ":\x05Stream\n One:$DATA",
+               ":MStream Two:$DATA",
+               ":?Stream*:$DATA"
+       };
+       const char *five1[5] = {
+               "::$DATA",
+               ":\x05Stream\n One:$DATA",
+               ":BeforeRename:$DATA",
+               ":MStream Two:$DATA",
+               ":?Stream*:$DATA"
+       };
+       const char *five2[5] = {
+               "::$DATA",
+               ":\x05Stream\n One:$DATA",
+               ":AfterRename:$DATA",
+               ":MStream Two:$DATA",
+               ":?Stream*:$DATA"
+       };
+
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "\x05Stream\n One");
+       sname1b = talloc_asprintf(mem_ctx, "%s:", sname1);
+       sname1c = talloc_asprintf(mem_ctx, "%s:$FOO", sname1);
+       sname1d = talloc_asprintf(mem_ctx, "%s:?D*a", sname1);
+       sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname, "MStream Two");
+       snamew = talloc_asprintf(mem_ctx, "%s:%s:$DATA", fname, "?Stream*");
+       snamew2 = talloc_asprintf(mem_ctx, "%s\\stream*:%s:$DATA", DNAME,
+                                 "?Stream*");
+       snamer1 = talloc_asprintf(mem_ctx, "%s:%s:$DATA", fname,
+                                 "BeforeRename");
+       snamer2 = talloc_asprintf(mem_ctx, "%s:%s:$DATA", fname, "AfterRename");
+
+       /* clean slate ...*/
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       torture_comment(tctx, "(%s) testing stream names\n", __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       /*
+        * A different stream does not give a sharing violation
+        */
+
+       io.smb2.in.fname = sname2;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h2 = io.smb2.out.file.handle;
+
+       /*
+        * ... whereas the same stream does with unchanged access/share_access
+        * flags
+        */
+
+       io.smb2.in.fname = sname1;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_SUPERSEDE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+       io.smb2.in.fname = sname1b;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
+
+       io.smb2.in.fname = sname1c;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
+               /* w2k returns INVALID_PARAMETER */
+               CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
+       } else {
+               CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
+       }
+
+       io.smb2.in.fname = sname1d;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
+               /* w2k returns INVALID_PARAMETER */
+               CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
+       } else {
+               CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
+       }
+
+       io.smb2.in.fname = sname2;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+       io.smb2.in.fname = snamew;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h3 = io.smb2.out.file.handle;
+
+       io.smb2.in.fname = snamew2;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
+
+       io.smb2.in.fname = fname;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       ret &= check_stream_list(tree, tctx, fname, 4, four,
+                                io.smb2.out.file.handle);
+
+       smb2_util_close(tree, h1);
+       smb2_util_close(tree, h2);
+       smb2_util_close(tree, h3);
+
+       if (torture_setting_bool(tctx, "samba4", true)) {
+               goto done;
+       }
+
+       finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
+       finfo.generic.in.file.handle = io.smb2.out.file.handle;
+       status = smb2_getinfo_file(tree, mem_ctx, &finfo);
+       CHECK_STATUS(status, NT_STATUS_OK);
+       ret &= check_stream_list(tree, tctx, fname, 4, four,
+                                io.smb2.out.file.handle);
+
+       for (i=0; i < 4; i++) {
+               NTTIME write_time;
+               uint64_t stream_size;
+               char *path = talloc_asprintf(tctx, "%s%s",
+                                            fname, four[i]);
+
+               char *rpath = talloc_strdup(path, path);
+               char *p = strrchr(rpath, ':');
+               /* eat :$DATA */
+               *p = 0;
+               p--;
+               if (*p == ':') {
+                       /* eat ::$DATA */
+                       *p = 0;
+               }
+               torture_comment(tctx, "(%s): i[%u][%s]\n",
+                   __location__, i,path);
+               io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+               io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_RIGHTS_FILE_ALL;
+               io.smb2.in.fname = path;
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               CHECK_STATUS(status, NT_STATUS_OK);
+               h1 = io.smb2.out.file.handle;
+
+               finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
+               finfo.generic.in.file.path = fname;
+               status = smb2_getinfo_file(tree, mem_ctx, &finfo);
+               CHECK_STATUS(status, NT_STATUS_OK);
+
+               stinfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
+               stinfo.generic.in.file.handle = h1;
+               status = smb2_getinfo_file(tree, mem_ctx, &stinfo);
+               CHECK_STATUS(status, NT_STATUS_OK);
+               if (!torture_setting_bool(tctx, "samba3", false)) {
+                       CHECK_NTTIME(stinfo.all_info.out.create_time,
+                                    finfo.all_info.out.create_time);
+                       CHECK_NTTIME(stinfo.all_info.out.access_time,
+                                    finfo.all_info.out.access_time);
+                       CHECK_NTTIME(stinfo.all_info.out.write_time,
+                                    finfo.all_info.out.write_time);
+                       CHECK_NTTIME(stinfo.all_info.out.change_time,
+                                    finfo.all_info.out.change_time);
+               }
+               CHECK_VALUE(stinfo.all_info.out.attrib,
+                           finfo.all_info.out.attrib);
+               CHECK_VALUE(stinfo.all_info.out.size,
+                           finfo.all_info.out.size);
+               CHECK_VALUE(stinfo.all_info.out.delete_pending,
+                           finfo.all_info.out.delete_pending);
+               CHECK_VALUE(stinfo.all_info.out.directory,
+                           finfo.all_info.out.directory);
+               CHECK_VALUE(stinfo.all_info.out.ea_size,
+                           finfo.all_info.out.ea_size);
+
+               stinfo.generic.level = RAW_FILEINFO_NAME_INFORMATION;
+               stinfo.generic.in.file.handle = h1;
+               status = smb2_getinfo_file(tree, mem_ctx, &stinfo);
+               CHECK_STATUS(status, NT_STATUS_OK);
+               if (!torture_setting_bool(tctx, "samba3", false)) {
+                       CHECK_STR(rpath, stinfo.name_info.out.fname.s);
+               }
+
+               write_time = finfo.all_info.out.write_time;
+               write_time += i*1000000;
+               write_time /= 1000000;
+               write_time *= 1000000;
+
+               ZERO_STRUCT(sinfo);
+               sinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION;
+               sinfo.basic_info.in.file.handle = h1;
+               sinfo.basic_info.in.write_time = write_time;
+               sinfo.basic_info.in.attrib = stinfo.all_info.out.attrib;
+               status = smb2_setinfo_file(tree, &sinfo);
+               CHECK_STATUS(status, NT_STATUS_OK);
+
+               stream_size = i*8192;
+
+               ZERO_STRUCT(sinfo);
+               sinfo.end_of_file_info.level =
+                       RAW_SFILEINFO_END_OF_FILE_INFORMATION;
+               sinfo.end_of_file_info.in.file.handle = h1;
+               sinfo.end_of_file_info.in.size = stream_size;
+               status = smb2_setinfo_file(tree, &sinfo);
+               CHECK_STATUS(status, NT_STATUS_OK);
+
+               stinfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
+               stinfo.generic.in.file.handle = h1;
+               status = smb2_getinfo_file(tree, mem_ctx, &stinfo);
+               CHECK_STATUS(status, NT_STATUS_OK);
+               if (!torture_setting_bool(tctx, "samba3", false)) {
+                       CHECK_NTTIME(stinfo.all_info.out.write_time,
+                                    write_time);
+                       CHECK_VALUE(stinfo.all_info.out.attrib,
+                                   finfo.all_info.out.attrib);
+               }
+               CHECK_VALUE(stinfo.all_info.out.size,
+                           stream_size);
+               CHECK_VALUE(stinfo.all_info.out.delete_pending,
+                           finfo.all_info.out.delete_pending);
+               CHECK_VALUE(stinfo.all_info.out.directory,
+                           finfo.all_info.out.directory);
+               CHECK_VALUE(stinfo.all_info.out.ea_size,
+                           finfo.all_info.out.ea_size);
+
+               io.smb2.in.fname = fname;
+               io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               CHECK_STATUS(status, NT_STATUS_OK);
+               ret &= check_stream_list(tree, tctx, fname, 4, four,
+                                        io.smb2.out.file.handle);
+
+               smb2_util_close(tree, h1);
+               talloc_free(path);
+       }
+
+       torture_comment(tctx, "(%s): testing stream renames\n", __location__);
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                               SEC_FILE_WRITE_ATTRIBUTE |
+                               SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.fname = snamer1;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+       ret &= check_stream_list(tree,tctx, fname, 5, five1,
+                                io.smb2.out.file.handle);
+
+       ZERO_STRUCT(sinfo);
+       sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.overwrite = true;
+       sinfo.rename_information.in.root_fid = 0;
+       sinfo.rename_information.in.new_name = ":AfterRename:$DATA";
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ret &= check_stream_list(tree,tctx, fname, 5, five2,
+                                io.smb2.out.file.handle);
+
+       ZERO_STRUCT(sinfo);
+       sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.overwrite = false;
+       sinfo.rename_information.in.root_fid = 0;
+       sinfo.rename_information.in.new_name = ":MStream Two:$DATA";
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
+
+       ret &= check_stream_list(tree,tctx, fname, 5, five2,
+                                io.smb2.out.file.handle);
+
+       ZERO_STRUCT(sinfo);
+       sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.overwrite = true;
+       sinfo.rename_information.in.root_fid = 0;
+       sinfo.rename_information.in.new_name = ":MStream Two:$DATA";
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
+
+       ret &= check_stream_list(tree,tctx, fname, 5, five2,
+                                io.smb2.out.file.handle);
+
+       /* TODO: we need to test more rename combinations */
+
+done:
+       smb2_util_close(tree, h1);
+       status = smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+/*
+  test stream names
+*/
+static bool test_stream_names2(struct torture_context *tctx,
+                              struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream_names2.txt";
+       bool ret = true;
+       struct smb2_handle h, h1;
+       uint8_t i;
+
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       torture_comment(tctx, "(%s) testing stream names\n", __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       for (i=0x01; i < 0x7F; i++) {
+               char *path = talloc_asprintf(mem_ctx, "%s:Stream%c0x%02X:$DATA",
+                                            fname, i, i);
+               NTSTATUS expected;
+
+               switch (i) {
+               case '/':/*0x2F*/
+               case ':':/*0x3A*/
+               case '\\':/*0x5C*/
+                       expected = NT_STATUS_OBJECT_NAME_INVALID;
+                       break;
+               default:
+                       expected = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                       break;
+               }
+
+
+               io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+               io.smb2.in.fname = path;
+               status = smb2_create(tree, mem_ctx, &(io.smb2));
+               if (!NT_STATUS_EQUAL(status, expected)) {
+                       torture_comment(tctx,
+                           "(%s) %s:Stream%c0x%02X:$DATA%s => expected[%s]\n",
+                           __location__, fname, isprint(i)?(char)i:' ', i,
+                           isprint(i)?"":" (not printable)",
+                           nt_errstr(expected));
+               }
+               CHECK_STATUS(status, expected);
+
+               talloc_free(path);
+       }
+
+done:
+       smb2_util_close(tree, h1);
+       status = smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+#define CHECK_CALL_HANDLE(call, rightstatus) do { \
+       check_handle = true; \
+       call_name = #call; \
+       sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
+       sfinfo.generic.in.file.handle = h1; \
+       status = smb2_setinfo_file(tree, &sfinfo); \
+       if (!NT_STATUS_EQUAL(status, rightstatus)) { \
+               torture_comment(tctx,"(%s) %s - %s (should be %s)\n", \
+                   __location__, #call, \
+                   nt_errstr(status), nt_errstr(rightstatus)); \
+               ret = false; \
+       } \
+       finfo1.generic.level = RAW_FILEINFO_ALL_INFORMATION; \
+       finfo1.generic.in.file.handle = h1; \
+       status2 = smb2_getinfo_file(tree, tctx, &finfo1); \
+       if (!NT_STATUS_IS_OK(status2)) { \
+               torture_comment(tctx,"(%s) %s pathinfo - %s\n", \
+                   __location__, #call, nt_errstr(status)); \
+               ret = false; \
+       }} while (0)
+
+/*
+  test stream renames
+*/
+static bool test_stream_rename(struct torture_context *tctx,
+                              struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status, status2;
+       union smb_open io;
+       const char *fname = DNAME "\\stream_rename.txt";
+       const char *sname1, *sname2;
+       union smb_fileinfo finfo1;
+       union smb_setfileinfo sfinfo;
+       bool ret = true;
+       struct smb2_handle h, h1;
+       bool check_handle;
+       const char *call_name;
+
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
+       sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname,
+                                "Second Stream");
+
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       torture_comment(tctx, "(%s) testing stream renames\n", __location__);
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
+                                     SEC_FILE_WRITE_ATTRIBUTE |
+                                   SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                       NTCREATEX_SHARE_ACCESS_WRITE |
+                       NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+
+       /* Create two streams. */
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+       smb2_util_close(tree, h1);
+
+       io.smb2.in.fname = sname2;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       smb2_util_close(tree, h1);
+
+       /*
+        * Open the second stream.
+        */
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       /*
+        * Now rename the second stream onto the first.
+        */
+
+       ZERO_STRUCT(sfinfo);
+
+       sfinfo.rename_information.in.overwrite = 1;
+       sfinfo.rename_information.in.root_fid  = 0;
+       sfinfo.rename_information.in.new_name  = ":Stream One";
+       CHECK_CALL_HANDLE(RENAME_INFORMATION, NT_STATUS_OK);
+done:
+       smb2_util_close(tree, h1);
+       status = smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+static bool test_stream_rename2(struct torture_context *tctx,
+                               struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname1 = DNAME "\\stream_rename2.txt";
+       const char *fname2 = DNAME "\\stream2_rename2.txt";
+       const char *stream_name1 = ":Stream One:$DATA";
+       const char *stream_name2 = ":Stream Two:$DATA";
+       const char *stream_name_default = "::$DATA";
+       const char *sname1;
+       const char *sname2;
+       bool ret = true;
+       struct smb2_handle h, h1;
+       union smb_setfileinfo sinfo;
+
+       sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname1, "Stream One");
+       sname2 = talloc_asprintf(mem_ctx, "%s:%s", fname1, "Stream Two");
+
+       smb2_util_unlink(tree, fname1);
+       smb2_util_unlink(tree, fname2);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_READ_DATA |
+                               SEC_FILE_WRITE_DATA |
+                               SEC_STD_DELETE |
+                               SEC_FILE_APPEND_DATA |
+                               SEC_STD_READ_CONTROL;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                               NTCREATEX_SHARE_ACCESS_WRITE |
+                               NTCREATEX_SHARE_ACCESS_DELETE;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = sname1;
+
+       /* Open/create new stream. */
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       /*
+        * Reopen the stream for SMB2 renames.
+        */
+       io.smb2.in.fname = sname1;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       /*
+        * Check SMB2 rename of a stream using :<stream>.
+        */
+       torture_comment(tctx, "(%s) Checking SMB2 rename of a stream using "
+                       ":<stream>\n", __location__);
+       ZERO_STRUCT(sinfo);
+       sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION_SMB2;
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.overwrite = 1;
+       sinfo.rename_information.in.root_fid = 0;
+       sinfo.rename_information.in.new_name = stream_name1;
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       /*
+        * Check SMB2 rename of an overwriting stream using :<stream>.
+        */
+       torture_comment(tctx, "(%s) Checking SMB2 rename of an overwriting "
+                       "stream using :<stream>\n", __location__);
+
+       /* Create second stream. */
+       io.smb2.in.fname = sname2;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       /* Rename the first stream onto the second. */
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.new_name = stream_name2;
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, h1);
+
+       /*
+        * Reopen the stream with the new name.
+        */
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.fname = sname2;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       /*
+        * Check SMB2 rename of a stream using <base>:<stream>.
+        */
+       torture_comment(tctx, "(%s) Checking SMB2 rename of a stream using "
+                       "<base>:<stream>\n", __location__);
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.new_name = sname1;
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+
+       /*
+        * Check SMB2 rename to the default stream using :<stream>.
+        */
+       torture_comment(tctx, "(%s) Checking SMB2 rename to defaualt stream "
+                       "using :<stream>\n", __location__);
+       sinfo.rename_information.in.file.handle = h1;
+       sinfo.rename_information.in.new_name = stream_name_default;
+       status = smb2_setinfo_file(tree, &sinfo);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       smb2_util_close(tree, h1);
+
+ done:
+       smb2_util_close(tree, h1);
+       status = smb2_util_unlink(tree, fname1);
+       status = smb2_util_unlink(tree, fname2);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+static bool create_file_with_stream(struct torture_context *tctx,
+                                   struct smb2_tree *tree,
+                                   TALLOC_CTX *mem_ctx,
+                                   const char *base_fname,
+                                   const char *stream)
+{
+       NTSTATUS status;
+       bool ret = true;
+       union smb_open io;
+
+       /* Create a file with a stream */
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_READ_DATA |
+                               SEC_FILE_WRITE_DATA |
+                               SEC_FILE_APPEND_DATA |
+                               SEC_STD_READ_CONTROL;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = stream;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+ done:
+       smb2_util_close(tree, io.smb2.out.file.handle);
+       return ret;
+}
+
+
+/* Test how streams interact with create dispositions */
+static bool test_stream_create_disposition(struct torture_context *tctx,
+                                          struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream_create_disp.txt";
+       const char *stream = "Stream One:$DATA";
+       const char *fname_stream;
+       const char *default_stream_name = "::$DATA";
+       const char *stream_list[2];
+       bool ret = true;
+       struct smb2_handle h, h1;
+
+       /* clean slate .. */
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       fname_stream = talloc_asprintf(mem_ctx, "%s:%s", fname, stream);
+
+       stream_list[0] = talloc_asprintf(mem_ctx, ":%s", stream);
+       stream_list[1] = default_stream_name;
+
+       if (!create_file_with_stream(tctx, tree, mem_ctx, fname,
+                                    fname_stream)) {
+               goto done;
+       }
+
+       /* Open the base file with OPEN */
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_READ_DATA |
+                               SEC_FILE_WRITE_DATA |
+                               SEC_FILE_APPEND_DATA |
+                               SEC_STD_READ_CONTROL;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       /*
+        * check create open: sanity check
+        */
+       torture_comment(tctx, "(%s) Checking create disp: open\n",
+                       __location__);
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       if (!check_stream_list(tree, tctx, fname, 2, stream_list,
+                              io.smb2.out.file.handle)) {
+               goto done;
+       }
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       /*
+        * check create overwrite
+        */
+       torture_comment(tctx, "(%s) Checking create disp: overwrite\n",
+                       __location__);
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       if (!check_stream_list(tree, tctx, fname, 1, &default_stream_name,
+                              io.smb2.out.file.handle)) {
+               goto done;
+       }
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       /*
+        * check create overwrite_if
+        */
+       torture_comment(tctx, "(%s) Checking create disp: overwrite_if\n",
+                       __location__);
+       smb2_util_unlink(tree, fname);
+       if (!create_file_with_stream(tctx, tree, mem_ctx, fname, fname_stream))
+               goto done;
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       if (!check_stream_list(tree, tctx, fname, 1, &default_stream_name,
+                              io.smb2.out.file.handle)) {
+               goto done;
+       }
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       /*
+        * check create supersede
+        */
+       torture_comment(tctx, "(%s) Checking create disp: supersede\n",
+                       __location__);
+       smb2_util_unlink(tree, fname);
+       if (!create_file_with_stream(tctx, tree, mem_ctx, fname,
+                                    fname_stream)) {
+               goto done;
+       }
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_SUPERSEDE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       if (!check_stream_list(tree, tctx, fname, 1, &default_stream_name,
+                              io.smb2.out.file.handle)) {
+               goto done;
+       }
+       smb2_util_close(tree, io.smb2.out.file.handle);
+
+       /*
+        * check create overwrite_if on a stream.
+        */
+       torture_comment(tctx, "(%s) Checking create disp: overwrite_if on "
+                       "stream\n", __location__);
+       smb2_util_unlink(tree, fname);
+       if (!create_file_with_stream(tctx, tree, mem_ctx, fname,
+                                    fname_stream)) {
+               goto done;
+       }
+
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
+       io.smb2.in.fname = fname_stream;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       if (!check_stream_list(tree, tctx, fname, 2, stream_list,
+                              io.smb2.out.file.handle)) {
+               goto done;
+       }
+       smb2_util_close(tree, io.smb2.out.file.handle);
+ done:
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+static bool open_stream(struct smb2_tree *tree,
+                       struct torture_context *mem_ctx,
+                       const char *fname,
+                       struct smb2_handle *h_out)
+{
+       NTSTATUS status;
+       union smb_open io;
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.create_flags = 0;
+       io.smb2.in.desired_access = SEC_FILE_READ_DATA |
+                               SEC_FILE_WRITE_DATA |
+                               SEC_FILE_APPEND_DATA |
+                               SEC_STD_READ_CONTROL |
+                               SEC_FILE_WRITE_ATTRIBUTE;
+       io.smb2.in.create_options = 0;
+       io.smb2.in.file_attributes = 0;
+       io.smb2.in.share_access = 0;
+       io.smb2.in.alloc_size = 0;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+       io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
+       io.smb2.in.security_flags = 0;
+       io.smb2.in.fname = fname;
+
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       if (!NT_STATUS_IS_OK(status)) {
+               return false;
+       }
+       *h_out = io.smb2.out.file.handle;
+       return true;
+}
+
+
+/* Test the effect of setting attributes on a stream. */
+static bool test_stream_attributes(struct torture_context *tctx,
+                                  struct smb2_tree *tree)
+{
+       TALLOC_CTX *mem_ctx = talloc_new(tctx);
+       bool ret = true;
+       NTSTATUS status;
+       union smb_open io;
+       const char *fname = DNAME "\\stream_attr.txt";
+       const char *stream = "Stream One:$DATA";
+       const char *fname_stream;
+       struct smb2_handle h, h1;
+       union smb_fileinfo finfo;
+       union smb_setfileinfo sfinfo;
+       time_t basetime = (time(NULL) - 86400) & ~1;
+
+       torture_comment(tctx, "(%s) testing attribute setting on stream\n",
+                       __location__);
+
+       /* clean slate .. */
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, fname);
+       smb2_deltree(tree, DNAME);
+
+       status = torture_smb2_testdir(tree, DNAME, &h);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       fname_stream = talloc_asprintf(mem_ctx, "%s:%s", fname, stream);
+
+       /* Create a file with a stream with attribute FILE_ATTRIBUTE_ARCHIVE. */
+       ret = create_file_with_stream(tctx, tree, mem_ctx, fname,
+                                     fname_stream);
+       if (!ret) {
+               goto done;
+       }
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.fname = fname;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
+                                NTCREATEX_SHARE_ACCESS_WRITE |
+                                NTCREATEX_SHARE_ACCESS_DELETE;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       ZERO_STRUCT(finfo);
+       finfo.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
+       finfo.generic.in.file.handle = io.smb2.out.file.handle;
+       status = smb2_getinfo_file(tree, mem_ctx, &finfo);
+       CHECK_STATUS(status, NT_STATUS_OK);
+
+       if (finfo.basic_info.out.attrib != FILE_ATTRIBUTE_ARCHIVE) {
+               torture_comment(tctx, "(%s) Incorrect attrib %x - should be "
+                   "%x\n", __location__,
+                   (unsigned int)finfo.basic_info.out.attrib,
+                   (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
+               ret = false;
+               goto done;
+       }
+
+       smb2_util_close(tree, io.smb2.out.file.handle);
+       /* Now open the stream name. */
+
+       if (!open_stream(tree, tctx, fname_stream, &h1)) {
+               goto done;
+       }
+
+       /* Change the time on the stream. */
+       ZERO_STRUCT(sfinfo);
+       unix_to_nt_time(&sfinfo.basic_info.in.write_time, basetime);
+       sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
+       sfinfo.generic.in.file.handle = h1;
+       status = smb2_setinfo_file(tree, &sfinfo);
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
+               torture_comment(tctx, "(%s) %s - %s (should be %s)\n",
+                   __location__, "SETATTR",
+                   nt_errstr(status), nt_errstr(NT_STATUS_OK));
+               ret = false;
+               goto done;
+       }
+
+       smb2_util_close(tree, h1);
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.fname = fname;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       ZERO_STRUCT(finfo);
+       finfo.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
+       finfo.generic.in.file.handle = h1;
+       status = smb2_getinfo_file(tree, mem_ctx, &finfo);
+       if (!NT_STATUS_IS_OK(status)) {
+               torture_comment(tctx, "(%s) %s pathinfo - %s\n",
+                   __location__, "SETATTRE", nt_errstr(status));
+               ret = false;
+               goto done;
+       }
+
+       if (nt_time_to_unix(finfo.basic_info.out.write_time) != basetime) {
+               torture_comment(tctx, "(%s) time incorrect.\n", __location__);
+               ret = false;
+               goto done;
+       }
+       smb2_util_close(tree, h1);
+
+       if (!open_stream(tree, tctx, fname_stream, &h1)) {
+               goto done;
+       }
+
+       /* Changing attributes on stream */
+       ZERO_STRUCT(sfinfo);
+       sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
+
+       sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
+       sfinfo.generic.in.file.handle = h1;
+       status = smb2_setinfo_file(tree, &sfinfo);
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
+               torture_comment(tctx, "(%s) %s - %s (should be %s)\n",
+                       __location__, "SETATTR",
+                       nt_errstr(status), nt_errstr(NT_STATUS_OK));
+               ret = false;
+               goto done;
+       }
+
+       smb2_util_close(tree, h1);
+
+       ZERO_STRUCT(io.smb2);
+       io.smb2.in.fname = fname;
+       io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
+       io.smb2.in.desired_access = SEC_FILE_READ_DATA;
+       status = smb2_create(tree, mem_ctx, &(io.smb2));
+       CHECK_STATUS(status, NT_STATUS_OK);
+       h1 = io.smb2.out.file.handle;
+
+       ZERO_STRUCT(finfo);
+       finfo.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
+       finfo.generic.in.file.handle = h1;
+       status = smb2_getinfo_file(tree, mem_ctx, &finfo);
+       CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
+
+done:
+       smb2_util_close(tree, h1);
+       smb2_util_unlink(tree, fname);
+       smb2_deltree(tree, DNAME);
+       talloc_free(mem_ctx);
+
+       return ret;
+}
+
+
+/*
+   basic testing of streams calls SMB2
+*/
+struct torture_suite *torture_smb2_streams_init(void)
+{
+       struct torture_suite *suite =
+               torture_suite_create(talloc_autofree_context(), "STREAMS");
+
+       torture_suite_add_1smb2_test(suite, "DIR", test_stream_dir);
+       torture_suite_add_1smb2_test(suite, "IO", test_stream_io);
+       torture_suite_add_1smb2_test(suite, "SHAREMODES", test_stream_sharemodes);
+       torture_suite_add_1smb2_test(suite, "NAMES", test_stream_names);
+       torture_suite_add_1smb2_test(suite, "NAMES2", test_stream_names2);
+       torture_suite_add_1smb2_test(suite, "RENAME", test_stream_rename);
+       torture_suite_add_1smb2_test(suite, "RENAME2", test_stream_rename2);
+       torture_suite_add_1smb2_test(suite, "CREATE-DISPOSITION", test_stream_create_disposition);
+       torture_suite_add_1smb2_test(suite, "ATTRIBUTES", test_stream_attributes);
+       torture_suite_add_1smb2_test(suite, "DELETE", test_stream_delete);
+
+       suite->description = talloc_strdup(suite, "SMB2-STREAM tests");
+
+       return suite;
+}

diff --git a/source4/torture/smbtorture.c b/source4/torture/smbtorture.c
index ce8c704584dc63989464e72ef74e5f2da910eb81..08c5748a4075576ec2d4c87493950188fab0ce8e 100644 (file)
--- a/source4/torture/smbtorture.c
+++ b/source4/torture/smbtorture.c
@@ -436,8 +436,9 @@ int main(int argc,char *argv[])
        static int list_tests = 0;
        int num_extra_users = 0;
        enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
-             OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS,OPT_EXTRA_USER};
-       
+             OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS,
+             OPT_EXTRA_USER,};
+
        struct poptOption long_options[] = {
                POPT_AUTOHELP
                {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit)", NULL },
@@ -518,6 +519,9 @@ int main(int argc,char *argv[])
                                talloc_free(option);
                        }
                        break;
+               default:
+                       printf("bad command line option\n");
+                       exit(1);
                }
        }
 
@@ -529,6 +533,8 @@ int main(int argc,char *argv[])
                lp_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
        } else if (strcmp(target, "win7") == 0) {
                lp_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
+       } else if (strcmp(target, "onefs") == 0) {
+               lp_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
        }
 
        if (max_runtime) {

diff --git a/source4/torture/smbtorture.h b/source4/torture/smbtorture.h
index c1363fd4c13b0125d1d29551af71515dbf5d3f9f..ff371e50be4ac768e93137a2da527c4504281e0c 100644 (file)
--- a/source4/torture/smbtorture.h
+++ b/source4/torture/smbtorture.h
@@ -37,4 +37,27 @@ struct torture_test;
 int torture_init(void);
 bool torture_register_suite(struct torture_suite *suite);
 
+/* Server Functionality Support */
+
+/* Not all SMB server implementations support every aspect of the protocol.
+ * To allow smbtorture to provide useful data when run against these servers we
+ * define support parameters here, that will cause some tests to be skipped or
+ * the correctness checking of some tests to be conditional.
+ *
+ * The idea is that different server implementations can be specified on the
+ * command line such as "--target=win7" which will define the list of server
+ * parameters that are not supported.  This is mostly a black list of
+ * unsupported features with the default expectation being that all features are
+ * supported.
+ *
+ * Because we use parametric options we do not need to define these parameters
+ * anywhere, we just define the meaning of each here.*/
+
+/* torture:sacl_support
+ *
+ * This parameter specifies whether the server supports the setting and
+ * retrieval of System Access Control Lists.  This includes whether the server
+ * supports the use of the SEC_FLAG_SYSTEM_SECURITY bit in the open access
+ * mask.*/
+
 #endif /* __SMBTORTURE_H__ */

diff --git a/source4/torture/torture.c b/source4/torture/torture.c
index 39a8005e86dccfc6cd6d4d91278566d480147bf1..774681dac3cfdc08275c0a59e8f2fa346773abe0 100644 (file)
--- a/source4/torture/torture.c
+++ b/source4/torture/torture.c
@@ -68,6 +68,7 @@ _PUBLIC_ int torture_init(void)
        extern NTSTATUS torture_raw_init(void);
        extern NTSTATUS torture_unix_init(void);
        extern NTSTATUS torture_winbind_init(void);
+       extern NTSTATUS torture_drs_init(void);
        init_module_fn static_init[] = { STATIC_smbtorture_MODULES };
        init_module_fn *shared_init = load_samba_modules(NULL, cmdline_lp_ctx, "smbtorture");
 

diff --git a/source4/torture/util.h b/source4/torture/util.h
index 6a8ae36baf016cc17b59e7e924f0dfe7a03024a8..501d14d57c1d314c7471bb2f13ef0903f4f29fc3 100644 (file)
--- a/source4/torture/util.h
+++ b/source4/torture/util.h
@@ -93,5 +93,8 @@ NTSTATUS torture_second_tcon(TALLOC_CTX *mem_ctx,
                             struct smbcli_tree **res);
 
 
+NTSTATUS torture_check_privilege(struct smbcli_state *cli, 
+                                const char *sid_str,
+                                const char *privilege);
 
 #endif /* _TORTURE_UTIL_H_ */

diff --git a/source4/torture/util_smb.c b/source4/torture/util_smb.c
index 99b00d232939febb7f42dcb967a3e5c16b0727a9..b6f2bee635510aab8207174e52f51508bd54978a 100644 (file)
--- a/source4/torture/util_smb.c
+++ b/source4/torture/util_smb.c
@@ -33,6 +33,8 @@
 #include "auth/credentials/credentials.h"
 #include "libcli/resolve/resolve.h"
 #include "param/param.h"
+#include "libcli/security/security.h"
+#include "libcli/util/clilsa.h"
 
 
 /**
@@ -61,7 +63,7 @@ NTSTATUS create_directory_handle(struct smbcli_tree *tree, const char *dname, in
        mem_ctx = talloc_named_const(tree, 0, "create_directory_handle");
 
        io.generic.level = RAW_OPEN_NTCREATEX;
-       io.ntcreatex.in.root_fid = 0;
+       io.ntcreatex.in.root_fid.fnum = 0;
        io.ntcreatex.in.flags = 0;
        io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
        io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
@@ -927,3 +929,37 @@ NTSTATUS torture_second_tcon(TALLOC_CTX *mem_ctx,
        talloc_free(tmp_ctx);
        return NT_STATUS_OK;
 }
+
+/* 
+   a wrapper around smblsa_sid_check_privilege, that tries to take
+   account of the fact that the lsa privileges calls don't expand
+   group memberships, using an explicit check for administrator. There
+   must be a better way ...
+ */
+NTSTATUS torture_check_privilege(struct smbcli_state *cli, 
+                                const char *sid_str,
+                                const char *privilege)
+{
+       struct dom_sid *sid;
+       TALLOC_CTX *tmp_ctx = talloc_new(cli);
+       uint32_t rid;
+       NTSTATUS status;
+
+       sid = dom_sid_parse_talloc(tmp_ctx, sid_str);
+       if (sid == NULL) {
+               talloc_free(tmp_ctx);
+               return NT_STATUS_INVALID_SID;
+       }
+
+       status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
+       NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
+
+       if (rid == DOMAIN_RID_ADMINISTRATOR) {
+               /* assume the administrator has them all */
+               return NT_STATUS_OK;
+       }
+
+       talloc_free(tmp_ctx);
+
+       return smblsa_sid_check_privilege(cli, sid_str, privilege);
+}

diff --git a/source4/torture/winbind/config.mk b/source4/torture/winbind/config.mk
index d2c57e9c979746eb849eb3ef35ac7acda1cb32e2..2bd613d649b5e2f8d4fbbae8b5355c0988a59658 100644 (file)
--- a/source4/torture/winbind/config.mk
+++ b/source4/torture/winbind/config.mk
@@ -6,11 +6,11 @@ SUBSYSTEM = smbtorture
 OUTPUT_TYPE = MERGED_OBJ
 INIT_FUNCTION = torture_winbind_init
 PRIVATE_DEPENDENCIES = \
-               LIBWINBIND-CLIENT torture PAM_ERRORS
+               LIBWBCLIENT LIBWINBIND-CLIENT torture PAM_ERRORS
 # End SUBSYSTEM TORTURE_WINBIND
 #################################
 
-TORTURE_WINBIND_OBJ_FILES = $(addprefix $(torturesrcdir)/winbind/, winbind.o struct_based.o)
+TORTURE_WINBIND_OBJ_FILES = $(addprefix $(torturesrcdir)/winbind/, winbind.o struct_based.o) ../nsswitch/libwbclient/tests/wbclient.o
 
 $(eval $(call proto_header_template,$(torturesrcdir)/winbind/proto.h,$(TORTURE_WINBIND_OBJ_FILES:.o=.c)))
 

diff --git a/source4/torture/winbind/winbind.c b/source4/torture/winbind/winbind.c
index b12e92552edf3464b43dbdb9808a97a372e92603..63d31a5f1ed8d925710c7088ab2788c227c88bf2 100644 (file)
--- a/source4/torture/winbind/winbind.c
+++ b/source4/torture/winbind/winbind.c
@@ -26,6 +26,7 @@ NTSTATUS torture_winbind_init(void)
        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "WINBIND");
 
        torture_suite_add_suite(suite, torture_winbind_struct_init());
+       torture_suite_add_suite(suite, torture_wbclient());
 
        suite->description = talloc_strdup(suite, "WINBIND tests");
 

diff --git a/source4/winbind/wb_cmd_getgrgid.c b/source4/winbind/wb_cmd_getgrgid.c
index 80f4e9cfc32df4682d42b4c9a013a6856d62f667..010fa220b1838742320fcd7e04ed15bc8aec11be 100644 (file)
--- a/source4/winbind/wb_cmd_getgrgid.c
+++ b/source4/winbind/wb_cmd_getgrgid.c
@@ -27,7 +27,7 @@
 #include "smbd/service_task.h"
 #include "libnet/libnet_proto.h"
 #include "param/param.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "auth/credentials/credentials.h"
 
 struct cmd_getgrgid_state {

diff --git a/source4/winbind/wb_cmd_getgrnam.c b/source4/winbind/wb_cmd_getgrnam.c
index bfc30fc7a6bdb853b5681414edbdceb7e3440256..0e498811f9f8c89fbc1413f58add399544603274 100644 (file)
--- a/source4/winbind/wb_cmd_getgrnam.c
+++ b/source4/winbind/wb_cmd_getgrnam.c
@@ -27,7 +27,7 @@
 #include "winbind/wb_helper.h"
 #include "smbd/service_task.h"
 #include "libnet/libnet_proto.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 
 struct cmd_getgrnam_state {
        struct composite_context *ctx;

diff --git a/source4/winbind/wb_cmd_getpwuid.c b/source4/winbind/wb_cmd_getpwuid.c
index b4e3d972f845b0fe5b6b6f9bffa5dbd2ff67e810..488af561e2fa0da975e8998fb338b9f785b64fe1 100644 (file)
--- a/source4/winbind/wb_cmd_getpwuid.c
+++ b/source4/winbind/wb_cmd_getpwuid.c
@@ -27,7 +27,7 @@
 #include "smbd/service_task.h"
 #include "libnet/libnet_proto.h"
 #include "param/param.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "auth/credentials/credentials.h"
 
 struct cmd_getpwuid_state {

diff --git a/source4/winbind/wb_gid2sid.c b/source4/winbind/wb_gid2sid.c
index 834d869845e2d5811d605f6fc4c0630a0dadeecf..7fb77bfc353d44f014ba269d97f86e062a5de85f 100644 (file)
--- a/source4/winbind/wb_gid2sid.c
+++ b/source4/winbind/wb_gid2sid.c
@@ -24,7 +24,7 @@
 #include "winbind/wb_server.h"
 #include "smbd/service_task.h"
 #include "winbind/wb_helper.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "winbind/idmap.h"
 
 struct gid2sid_state {

diff --git a/source4/winbind/wb_irpc.c b/source4/winbind/wb_irpc.c
index 801c2e7dfa84656015f2688c5b0fe7ed39a2e9c3..efbc310b68180d6f50665c15ecec42d1f3e2baa4 100644 (file)
--- a/source4/winbind/wb_irpc.c
+++ b/source4/winbind/wb_irpc.c
@@ -22,7 +22,7 @@
 #include "winbind/wb_server.h"
 #include "lib/messaging/irpc.h"
 #include "libcli/composite/composite.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "librpc/gen_ndr/ndr_winbind.h"
 #include "smbd/service_task.h"
 
@@ -86,7 +86,7 @@ static NTSTATUS wb_irpc_get_idmap(struct irpc_message *msg,
        struct wbsrv_service *service = talloc_get_type(msg->private_data,
                                        struct wbsrv_service);
        struct wb_irpc_get_idmap_state *s;
-       struct composite_context *ctx;
+       struct composite_context *ctx = NULL;
 
        DEBUG(5, ("wb_irpc_get_idmap called\n"));
 

diff --git a/source4/winbind/wb_pam_auth.c b/source4/winbind/wb_pam_auth.c
index b2579fd6df191691b0404d3222d6c2e3156819dc..0a9c37911bf423c13b1b182297258fd2d0d8bac0 100644 (file)
--- a/source4/winbind/wb_pam_auth.c
+++ b/source4/winbind/wb_pam_auth.c
@@ -260,11 +260,31 @@ struct composite_context *wb_cmd_pam_auth_send(TALLOC_CTX *mem_ctx,
                                         chal, nt_resp, lm_resp);
 }
 
-NTSTATUS wb_cmd_pam_auth_recv(struct composite_context *c)
+NTSTATUS wb_cmd_pam_auth_recv(struct composite_context *c,
+                             TALLOC_CTX *mem_ctx,
+                             DATA_BLOB *info3,
+                             struct netr_UserSessionKey *user_session_key,
+                             struct netr_LMSessionKey *lm_key,
+                             char **unix_username)
 {
-       struct pam_auth_crap_state *state =
-               talloc_get_type(c->private_data, struct pam_auth_crap_state);
-       NTSTATUS status = composite_wait(c);
-       talloc_free(state);
-       return status;
+       struct pam_auth_crap_state *state =
+               talloc_get_type(c->private_data, struct pam_auth_crap_state);
+       NTSTATUS status = composite_wait(c);
+       if (NT_STATUS_IS_OK(status)) {
+               if (info3) {
+                       info3->length = state->info3.length;
+                       info3->data = talloc_steal(mem_ctx, state->info3.data);
+               }
+               if (user_session_key) {
+                       *user_session_key = state->user_session_key;
+               }
+               if (lm_key) {
+                       *lm_key = state->lm_key;
+               }
+               if (unix_username) {
+                       *unix_username = talloc_steal(mem_ctx, state->unix_username);
+               }
+       }
+       talloc_free(state);
+       return status;
 }

diff --git a/source4/winbind/wb_samba3_cmd.c b/source4/winbind/wb_samba3_cmd.c
index b219615b1e1264f37218aaab640e2b70179dc592..c5fba92f147d7b3bdd72781dfc4da081252045cc 100644 (file)
--- a/source4/winbind/wb_samba3_cmd.c
+++ b/source4/winbind/wb_samba3_cmd.c
@@ -29,11 +29,114 @@
 #include "libcli/composite/composite.h"
 #include "version.h"
 #include "librpc/gen_ndr/netlogon.h"
+#include "librpc/gen_ndr/ndr_netlogon.h"
 #include "libcli/security/security.h"
 #include "auth/ntlm/pam_errors.h"
 #include "auth/credentials/credentials.h"
 #include "smbd/service_task.h"
 
+/*
+  support the old Samba3 TXT form of the info3
+ */
+static NTSTATUS wb_samba3_append_info3_as_txt(TALLOC_CTX *mem_ctx,
+                                             struct wbsrv_samba3_call *s3call,
+                                             DATA_BLOB info3b)
+{
+       struct netr_SamInfo3 *info3;
+       char *ex;
+       uint32_t i;
+       enum ndr_err_code ndr_err;
+
+       info3 = talloc(mem_ctx, struct netr_SamInfo3);
+       NT_STATUS_HAVE_NO_MEMORY(info3);
+
+       /* The Samba3 protocol has a redundent 4 bytes at the start */
+       info3b.data += 4;
+       info3b.length -= 4;
+
+       ndr_err = ndr_pull_struct_blob(&info3b,
+                                      mem_ctx,
+                                      lp_iconv_convenience(s3call->wbconn->lp_ctx), 
+                                      info3,
+                                      (ndr_pull_flags_fn_t)ndr_pull_netr_SamInfo3);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               return ndr_map_error2ntstatus(ndr_err);
+       }
+
+       s3call->response.data.auth.info3.logon_time =
+               nt_time_to_unix(info3->base.last_logon);
+       s3call->response.data.auth.info3.logoff_time =
+               nt_time_to_unix(info3->base.last_logoff);
+       s3call->response.data.auth.info3.kickoff_time =
+               nt_time_to_unix(info3->base.acct_expiry);
+       s3call->response.data.auth.info3.pass_last_set_time =
+               nt_time_to_unix(info3->base.last_password_change);
+       s3call->response.data.auth.info3.pass_can_change_time =
+               nt_time_to_unix(info3->base.allow_password_change);
+       s3call->response.data.auth.info3.pass_must_change_time =
+               nt_time_to_unix(info3->base.force_password_change);
+
+       s3call->response.data.auth.info3.logon_count = info3->base.logon_count;
+       s3call->response.data.auth.info3.bad_pw_count = info3->base.bad_password_count;
+
+       s3call->response.data.auth.info3.user_rid = info3->base.rid;
+       s3call->response.data.auth.info3.group_rid = info3->base.primary_gid;
+       fstrcpy(s3call->response.data.auth.info3.dom_sid, dom_sid_string(mem_ctx, info3->base.domain_sid));
+
+       s3call->response.data.auth.info3.num_groups = info3->base.groups.count;
+       s3call->response.data.auth.info3.user_flgs = info3->base.user_flags;
+
+       s3call->response.data.auth.info3.acct_flags = info3->base.acct_flags;
+       s3call->response.data.auth.info3.num_other_sids = info3->sidcount;
+
+       fstrcpy(s3call->response.data.auth.info3.user_name,
+               info3->base.account_name.string);
+       fstrcpy(s3call->response.data.auth.info3.full_name,
+               info3->base.full_name.string);
+       fstrcpy(s3call->response.data.auth.info3.logon_script,
+               info3->base.logon_script.string);
+       fstrcpy(s3call->response.data.auth.info3.profile_path,
+               info3->base.profile_path.string);
+       fstrcpy(s3call->response.data.auth.info3.home_dir,
+               info3->base.home_directory.string);
+       fstrcpy(s3call->response.data.auth.info3.dir_drive,
+               info3->base.home_drive.string);
+
+       fstrcpy(s3call->response.data.auth.info3.logon_srv,
+               info3->base.logon_server.string);
+       fstrcpy(s3call->response.data.auth.info3.logon_dom,
+               info3->base.domain.string);
+
+       ex = talloc_strdup(mem_ctx, "");
+       NT_STATUS_HAVE_NO_MEMORY(ex);
+
+       for (i=0; i < info3->base.groups.count; i++) {
+               ex = talloc_asprintf_append_buffer(ex, "0x%08X:0x%08X\n",
+                                                  info3->base.groups.rids[i].rid,
+                                                  info3->base.groups.rids[i].attributes);
+               NT_STATUS_HAVE_NO_MEMORY(ex);
+       }
+
+       for (i=0; i < info3->sidcount; i++) {
+               char *sid;
+
+               sid = dom_sid_string(mem_ctx, info3->sids[i].sid);
+               NT_STATUS_HAVE_NO_MEMORY(sid);
+
+               ex = talloc_asprintf_append_buffer(ex, "%s:0x%08X\n",
+                                                  sid,
+                                                  info3->sids[i].attributes);
+               NT_STATUS_HAVE_NO_MEMORY(ex);
+
+               talloc_free(sid);
+       }
+
+       s3call->response.extra_data.data = ex;
+       s3call->response.length += talloc_get_size(ex);
+
+       return NT_STATUS_OK;
+}
+
 /* 
    Send off the reply to an async Samba3 query, handling filling in the PAM, NTSTATUS and string errors.
 */
@@ -196,7 +299,7 @@ static void check_machacc_recv(struct composite_context *ctx)
                                struct wbsrv_samba3_call);
        NTSTATUS status;
 
-       status = wb_cmd_pam_auth_recv(ctx);
+       status = wb_cmd_pam_auth_recv(ctx, s3call, NULL, NULL, NULL, NULL);
 
        if (!NT_STATUS_IS_OK(status)) goto done;
 
@@ -554,6 +657,15 @@ static void pam_auth_crap_recv(struct composite_context *ctx)
                       sizeof(s3call->response.data.auth.user_session_key));
        }
 
+       if (s3call->request.flags & WBFLAG_PAM_INFO3_TEXT) {
+               status = wb_samba3_append_info3_as_txt(ctx, s3call, info3);
+               if (!NT_STATUS_IS_OK(status)) {
+                       DEBUG(10,("Failed to append INFO3 (TXT): %s\n",
+                                 nt_errstr(status)));
+                       goto done;
+               }
+       }
+
        if (s3call->request.flags & WBFLAG_PAM_INFO3_NDR) {
                s3call->response.extra_data.data = info3.data;
                s3call->response.length += info3.length;
@@ -622,11 +734,48 @@ static void pam_auth_recv(struct composite_context *ctx)
                talloc_get_type(ctx->async.private_data,
                                struct wbsrv_samba3_call);
        NTSTATUS status;
+       DATA_BLOB info3;
+       struct netr_UserSessionKey user_session_key;
+       struct netr_LMSessionKey lm_key;
+       char *unix_username;
 
-       status = wb_cmd_pam_auth_recv(ctx);
+       status = wb_cmd_pam_auth_recv(ctx, s3call, &info3, 
+                                     &user_session_key, &lm_key, &unix_username);
 
        if (!NT_STATUS_IS_OK(status)) goto done;
 
+       if (s3call->request.flags & WBFLAG_PAM_USER_SESSION_KEY) {
+               memcpy(s3call->response.data.auth.user_session_key, 
+                      &user_session_key.key,
+                      sizeof(s3call->response.data.auth.user_session_key));
+       }
+
+       if (s3call->request.flags & WBFLAG_PAM_INFO3_TEXT) {
+               status = wb_samba3_append_info3_as_txt(ctx, s3call, info3);
+               if (!NT_STATUS_IS_OK(status)) {
+                       DEBUG(10,("Failed to append INFO3 (TXT): %s\n",
+                                 nt_errstr(status)));
+                       goto done;
+               }
+       }
+
+       if (s3call->request.flags & WBFLAG_PAM_INFO3_NDR) {
+               s3call->response.extra_data.data = info3.data;
+               s3call->response.length += info3.length;
+       }
+
+       if (s3call->request.flags & WBFLAG_PAM_LMKEY) {
+               memcpy(s3call->response.data.auth.first_8_lm_hash, 
+                      lm_key.key,
+                      sizeof(s3call->response.data.auth.first_8_lm_hash));
+       }
+       
+       if (s3call->request.flags & WBFLAG_PAM_UNIX_NAME) {
+               s3call->response.extra_data.data = unix_username;
+               s3call->response.length += strlen(unix_username)+1;
+       }
+       
+
  done:
        wbsrv_samba3_async_auth_epilogue(status, s3call);
 }

diff --git a/source4/winbind/wb_sids2xids.c b/source4/winbind/wb_sids2xids.c
index 6b89caf4657fc1cf6757669c16f4a94ed5cf4b5b..d31ac08cf7eb764840a1d6e277a4423320d75724 100644 (file)
--- a/source4/winbind/wb_sids2xids.c
+++ b/source4/winbind/wb_sids2xids.c
@@ -24,7 +24,7 @@
 #include "winbind/wb_server.h"
 #include "smbd/service_task.h"
 #include "winbind/wb_helper.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "winbind/idmap.h"
 
 struct sids2xids_state {

diff --git a/source4/winbind/wb_uid2sid.c b/source4/winbind/wb_uid2sid.c
index fd43dd64b99621554d55ba55acc106de48e62677..d626f58eb68bf17d99782a665eaee4f4d282375e 100644 (file)
--- a/source4/winbind/wb_uid2sid.c
+++ b/source4/winbind/wb_uid2sid.c
@@ -24,7 +24,7 @@
 #include "winbind/wb_server.h"
 #include "smbd/service_task.h"
 #include "winbind/wb_helper.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "winbind/idmap.h"
 
 struct uid2sid_state {

diff --git a/source4/winbind/wb_xids2sids.c b/source4/winbind/wb_xids2sids.c
index a1cf2667ff2baa43e18732324f85798278a2c06e..dfad51943b91fdab9fc8bbbe419ff66b1545d576 100644 (file)
--- a/source4/winbind/wb_xids2sids.c
+++ b/source4/winbind/wb_xids2sids.c
@@ -24,7 +24,7 @@
 #include "winbind/wb_server.h"
 #include "smbd/service_task.h"
 #include "winbind/wb_helper.h"
-#include "libcli/security/proto.h"
+#include "libcli/security/security.h"
 #include "winbind/idmap.h"
 
 struct xids2sids_state {