root/source4/torture/ndr/winreg.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. closekey_in_check
  2. closekey_out_check
  3. openhklm_in_check
  4. openhklm_out_check
  5. createkey_in_check
  6. createkey_out_check
  7. enumvalue_in_check
  8. enumvalue_out_check
  9. queryvalue_in_check
  10. queryvalue_out_check
  11. querymultiplevalues_in_check
  12. querymultiplevalues_out_check
  13. flushkey_in_check
  14. flushkey_out_check
  15. openkey_in_check
  16. openkey_out_check
  17. deletekey_in_check
  18. deletekey_out_check
  19. getversion_in_check
  20. getversion_out_check
  21. queryinfokey_in_check
  22. queryinfokey_out_check
  23. notifychangekeyvalue_in_check
  24. notifychangekeyvalue_out_check
  25. getkeysecurity_in_check
  26. getkeysecurity_out_check
  27. enumkey_in_check
  28. enumkey_out_check
  29. ndr_winreg_suite

   1 /* 
   2    Unix SMB/CIFS implementation.
   3    test suite for winreg ndr operations
   4 
   5    Copyright (C) Jelmer Vernooij 2007
   6    
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11    
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16    
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 
  21 #include "includes.h"
  22 #include "torture/ndr/ndr.h"
  23 #include "librpc/gen_ndr/ndr_winreg.h"
  24 #include "librpc/gen_ndr/ndr_security.h"
  25 #include "libcli/security/security.h"
  26 
  27 static const uint8_t closekey_in_data[] = { 
  28         0x00, 0x00, 0x00, 0x00, 0x1d, 0xd8, 0xd7, 0xaa, 0x8d, 0x6c, 0x3f, 0x48, 
  29         0xa7, 0x1e, 0x02, 0x6a, 0x47, 0xf6, 0x7b, 0xae
  30 };
  31 
  32 static bool closekey_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
  33                                                                   struct winreg_CloseKey *ck)
  34 {
  35         torture_assert(tctx, ck->in.handle != NULL, "handle invalid");
  36         torture_assert_int_equal(tctx, ck->in.handle->handle_type, 0, "handle type");
  37         return true;
  38 }
  39 
  40 const static uint8_t closekey_out_data[] = {
  41   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  42   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  43 };
  44 
  45 static bool closekey_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
  46                                                            struct winreg_CloseKey *ck)
  47 {
  48         torture_assert_int_equal(tctx, ck->out.handle->handle_type, 0, "handle type");
  49         torture_assert_werr_ok(tctx, ck->out.result, "return code");
  50         return true;
  51 }
  52 
  53 static const uint8_t OpenHKLM_In[] = {
  54   0x01, 0x00, 0x00, 0x00, 0xe0, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
  55 };
  56 
  57 static bool openhklm_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
  58                                                                   struct winreg_OpenHKLM *r)
  59 {
  60         torture_assert(tctx, r->in.system_name != NULL, "system name pointer");
  61         torture_assert_int_equal(tctx, *r->in.system_name, 34016, "system name");
  62         torture_assert_int_equal(tctx, r->in.access_mask, 0x02000000, "access mask");
  63         return true;
  64 }
  65 
  66 static const uint8_t openhklm_out_data[] = {
  67   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
  68   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x00, 0x00, 0x00, 0x00
  69 };
  70 
  71 static bool openhklm_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
  72                                                                   struct winreg_OpenHKLM *r)
  73 {
  74         torture_assert(tctx, r->out.handle != NULL, "handle pointer");
  75         torture_assert_int_equal(tctx, r->out.handle->handle_type, 0, "handle_type");
  76         torture_assert_werr_ok(tctx, r->out.result, "return code");
  77         return true;
  78 }
  79 
  80 static const uint8_t createkey_in_data[] = {
  81   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
  82   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x16, 0x00, 0x16, 0x00,
  83   0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  84   0x0b, 0x00, 0x00, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x74, 0x00,
  85   0x74, 0x00, 0x79, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00,
  86   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  87   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
  88   0x00, 0x00, 0x00, 0x00
  89 };
  90 
  91 static bool createkey_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
  92                                                                   struct winreg_CreateKey *r)
  93 {
  94         torture_assert_str_equal(tctx, r->in.name.name, "spottyfoot", "name");
  95         torture_assert(tctx, r->in.keyclass.name == NULL, "keyclass");
  96         torture_assert_int_equal(tctx, r->in.options, 0, "option");
  97         torture_assert_int_equal(tctx, r->in.access_mask, 0x2000000, "access mask");
  98         torture_assert(tctx, r->in.secdesc == NULL, "secdesc");
  99         torture_assert(tctx, r->in.action_taken == NULL, "action_taken");
 100 
 101         return true;
 102 }
 103 
 104 static const uint8_t createkey_out_data[] = {
 105   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 106   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 107   0x57, 0x00, 0x00, 0x00
 108 };
 109 
 110 static bool createkey_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 111                                                                   struct winreg_CreateKey *r)
 112 {
 113         torture_assert(tctx, GUID_all_zero(&r->out.new_handle->uuid), "new_handle");
 114         torture_assert(tctx, r->out.action_taken == NULL, "action_taken pointer");
 115         torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, 
 116                                                           "return code");
 117 
 118         return true;
 119 }
 120 
 121 static const uint8_t enumvalue_in_data[] = {
 122   0x00, 0x00, 0x00, 0x00, 0xae, 0x1a, 0xbd, 0xbe, 0xbb, 0x94, 0xce, 0x4e,
 123   0xba, 0xcf, 0x56, 0xeb, 0xe5, 0xb3, 0x6c, 0xa3, 0x05, 0x00, 0x00, 0x00,
 124   0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 125   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 126   0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
 127   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
 128   0xff, 0xff, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 129 };
 130 
 131 static bool enumvalue_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 132                                                                   struct winreg_EnumValue *r)
 133 {
 134         torture_assert_int_equal(tctx, r->in.enum_index, 5, "enum index");
 135         torture_assert(tctx, r->in.type != NULL, "type pointer");
 136         torture_assert_int_equal(tctx, *r->in.type, 0, "type");
 137         torture_assert_int_equal(tctx, *r->in.size, 65535, "size");
 138         torture_assert_int_equal(tctx, *r->in.length, 0, "length");
 139         torture_assert_int_equal(tctx, r->in.name->size, 512, "name size");
 140         torture_assert_int_equal(tctx, r->in.name->length, 0, "name length");
 141 
 142         return true;
 143 }
 144 
 145 static const uint8_t enumvalue_out_data[] = {
 146   0x12, 0x00, 0x00, 0x02, 0x28, 0x91, 0x08, 0x00, 0x00, 0x01, 0x00, 0x00,
 147   0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4f, 0x00,
 148   0x4d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x41, 0x00, 0x54, 0x00, 0x48, 0x00,
 149   0x00, 0x00, 0x00, 0x00, 0xd8, 0x8c, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00,
 150   0xe0, 0x00, 0x0c, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 151   0x4c, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x44, 0x00, 0x6f, 0x00, 0x63, 0x00,
 152   0x75, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x73, 0x00,
 153   0x20, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x20, 0x00, 0x53, 0x00,
 154   0x65, 0x00, 0x74, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00,
 155   0x73, 0x00, 0x5c, 0x00, 0x41, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x69, 0x00,
 156   0x6e, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61, 0x00,
 157   0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x00, 0x00, 0xf0, 0x8c, 0x07, 0x00,
 158   0x4c, 0x00, 0x00, 0x00, 0xf8, 0x8c, 0x07, 0x00, 0x4c, 0x00, 0x00, 0x00,
 159   0x00, 0x00, 0x00, 0x00
 160 };
 161 
 162 static bool enumvalue_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 163                                                                   struct winreg_EnumValue *r)
 164 {
 165         torture_assert_int_equal(tctx, r->out.name->size, 512, "name size");
 166         torture_assert_int_equal(tctx, r->out.name->length, 18, "name length");
 167         torture_assert_str_equal(tctx, r->out.name->name, "HOMEPATH", "name");
 168         torture_assert_int_equal(tctx, *r->out.type, 1, "type");
 169         torture_assert_int_equal(tctx, *r->out.size, 76, "size");
 170         torture_assert_int_equal(tctx, *r->out.length, 76, "length");
 171         torture_assert_werr_ok(tctx, r->out.result, "return code");
 172 
 173         return true;
 174 }
 175 
 176 unsigned char enumvalue_in_data2[] = {
 177   0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 178   0xda, 0x45, 0x9c, 0xed, 0xe2, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 179   0x00, 0x00, 0x00, 0x02, 0xcc, 0xf9, 0x06, 0x00, 0x00, 0x01, 0x00, 0x00,
 180   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0xf9, 0x06, 0x00,
 181   0x39, 0xa6, 0x07, 0x00, 0x00, 0xc4, 0x04, 0x01, 0x00, 0x80, 0x00, 0x00,
 182   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xf9, 0x06, 0x00,
 183   0x00, 0x80, 0x00, 0x00, 0x94, 0xf9, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00
 184 };
 185 
 186 static const uint8_t queryvalue_in_data[] = {
 187   0x00, 0x00, 0x00, 0x00, 0xae, 0x1a, 0xbd, 0xbe, 0xbb, 0x94, 0xce, 0x4e,
 188   0xba, 0xcf, 0x56, 0xeb, 0xe5, 0xb3, 0x6c, 0xa3, 0x12, 0x00, 0x12, 0x00,
 189   0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 190   0x09, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4f, 0x00, 0x4d, 0x00, 0x45, 0x00,
 191   0x50, 0x00, 0x41, 0x00, 0x54, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00,
 192   0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 193   0x03, 0x00, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
 194   0x00, 0x00, 0x00, 0x00
 195 };
 196 
 197 static bool queryvalue_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 198                                                                   struct winreg_QueryValue *r)
 199 {
 200         torture_assert_str_equal(tctx, r->in.value_name->name, "HOMEPATH", "name");
 201         torture_assert_int_equal(tctx, *r->in.type, 0, "type");
 202         torture_assert_int_equal(tctx, *r->in.data_size, 4095, "size");
 203         torture_assert_int_equal(tctx, *r->in.data_length, 0, "length");
 204         torture_assert(tctx, r->in.data == NULL, "data pointer");
 205 
 206         return true;
 207 }
 208 
 209 static const uint8_t queryvalue_out_data[] = {
 210   0xd8, 0xf5, 0x0b, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 211   0xe4, 0xf5, 0x0b, 0x00, 0x4c, 0x00, 0x00, 0x00, 0xec, 0xf5, 0x0b, 0x00,
 212   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 213 };
 214 
 215 static bool queryvalue_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 216                                                                   struct winreg_QueryValue *r)
 217 {
 218         torture_assert_werr_ok(tctx, r->out.result, "return code");
 219         torture_assert_int_equal(tctx, *r->out.type, 1, "type");
 220         torture_assert(tctx, r->out.data == NULL, "data pointer");
 221         torture_assert_int_equal(tctx, *r->out.data_size, 76, "size");
 222         torture_assert_int_equal(tctx, *r->out.data_length, 0, "length");
 223 
 224         return true;
 225 }
 226 
 227 static const uint8_t querymultiplevalues_in_data[] = {
 228   0x00, 0x00, 0x00, 0x00, 0xae, 0x1a, 0xbd, 0xbe, 0xbb, 0x94, 0xce, 0x4e,
 229   0xba, 0xcf, 0x56, 0xeb, 0xe5, 0xb3, 0x6c, 0xa3, 0x01, 0x00, 0x00, 0x00,
 230   0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 231   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 232   0x12, 0x00, 0x12, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
 233   0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4f, 0x00,
 234   0x4d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x41, 0x00, 0x54, 0x00, 0x48, 0x00,
 235   0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
 236   0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
 237   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 238   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 239   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00
 240 };
 241 
 242 static bool querymultiplevalues_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 243                                          struct winreg_QueryMultipleValues *r)
 244 {
 245         torture_assert_int_equal(tctx, r->in.num_values, 1, "num values");
 246         torture_assert_str_equal(tctx, r->in.values[0].name->name, "HOMEPATH", 
 247                                                          "name");
 248 
 249         torture_assert_int_equal(tctx, r->in.values[0].type, 0, "type");
 250         torture_assert_int_equal(tctx, r->in.values[0].offset, 0, "offset");
 251         torture_assert_int_equal(tctx, r->in.values[0].length, 0, "length");
 252         torture_assert_int_equal(tctx, *r->in.buffer_size, 76, "buffer size");
 253 
 254         return true;
 255 }
 256 
 257 static const uint8_t querymultiplevalues_out_data[] = {
 258   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 259   0xd8, 0x8c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 260   0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x12, 0x00, 0x38, 0x87, 0x07, 0x00,
 261   0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 262   0x48, 0x00, 0x4f, 0x00, 0x4d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x41, 0x00,
 263   0x54, 0x00, 0x48, 0x00, 0xc8, 0x95, 0x08, 0x00, 0x4c, 0x00, 0x00, 0x00,
 264   0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 265   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 266   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 267   0x00, 0x00, 0x00, 0x00, 0x4c, 0x4d, 0x45, 0x4d, 0xc8, 0x95, 0x08, 0x00,
 268   0x50, 0x87, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x07, 0x00,
 269   0x00, 0x01, 0x0c, 0x00, 0x50, 0x95, 0x08, 0x00, 0x48, 0x96, 0x08, 0x00,
 270   0xdc, 0x00, 0x00, 0x00, 0xc0, 0x83, 0x00, 0x01, 0x0d, 0xf0, 0xff, 0xff,
 271   0x4c, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00
 272 };
 273 
 274 static bool querymultiplevalues_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 275                                           struct winreg_QueryMultipleValues *r)
 276 {
 277         torture_assert_str_equal(tctx, r->out.values[0].name->name, "HOMEPATH", 
 278                                                          "name");
 279 
 280         torture_assert_int_equal(tctx, r->out.values[0].type, 0, "type");
 281         torture_assert_int_equal(tctx, r->out.values[0].offset, 0, "offset");
 282         torture_assert_int_equal(tctx, r->out.values[0].length, 0, "length");
 283         /* FIXME: r->out.buffer */
 284         torture_assert_int_equal(tctx, *r->out.buffer_size, 76, "buffer size");
 285         torture_assert_werr_equal(tctx, r->out.result, WERR_MORE_DATA, 
 286                                                                   "return code");
 287 
 288         return true;
 289 }
 290 
 291 static const uint8_t flushkey_in_data[] = {
 292   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
 293   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3
 294 };
 295 
 296 static bool flushkey_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 297                                                            struct winreg_FlushKey *r)
 298 {
 299         torture_assert_int_equal(tctx, r->in.handle->handle_type, 0, "handle type");
 300         return true;
 301 }
 302 
 303 static const uint8_t flushkey_out_data[] = {
 304   0x00, 0x00, 0x00, 0x00
 305 };
 306 
 307 static bool flushkey_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 308                                                            struct winreg_FlushKey *r)
 309 {
 310         torture_assert_werr_ok(tctx, r->out.result, "return code");
 311         return true;
 312 }
 313 
 314 
 315 static const uint8_t openkey_in_data[] = {
 316   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
 317   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x16, 0x00, 0x16, 0x00,
 318   0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 319   0x0b, 0x00, 0x00, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x74, 0x00,
 320   0x74, 0x00, 0x79, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00,
 321   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
 322 };
 323 
 324 static bool openkey_in_check(struct torture_context *tctx, struct winreg_OpenKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 325 {
 326         torture_assert_int_equal(tctx, r->in.unknown, 0, "unknown");
 327         torture_assert_int_equal(tctx, r->in.access_mask, 0x02000000, "access mask");
 328         torture_assert_str_equal(tctx, r->in.keyname.name, "spottyfoot", "keyname");
 329         /* FIXME: parent handle */
 330         return true;
 331 }
 332 
 333 static const uint8_t openkey_out_data[] = {
 334   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 335   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00
 336 };
 337 
 338 static bool openkey_out_check(struct torture_context *tctx, struct winreg_OpenKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 339 {
 340         torture_assert(tctx, GUID_all_zero(&r->out.handle->uuid), "handle");
 341         torture_assert_werr_equal(tctx, r->out.result, WERR_BADFILE, "return code");
 342         return true;
 343 }
 344 
 345 static const uint8_t deletekey_in_data[] = {
 346   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
 347   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x16, 0x00, 0x16, 0x00,
 348   0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 349   0x0b, 0x00, 0x00, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x74, 0x00,
 350   0x74, 0x00, 0x79, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00,
 351   0x00, 0x00
 352 };
 353 
 354 static bool deletekey_in_check(struct torture_context *tctx, struct winreg_DeleteKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 355 {
 356         /* FIXME: Handle */
 357         torture_assert_str_equal(tctx, r->in.key.name, "spottyfoot", "key name");
 358         return true;
 359 }
 360 
 361 static const uint8_t deletekey_out_data[] = {
 362   0x02, 0x00, 0x00, 0x00
 363 };
 364 
 365 static bool deletekey_out_check(struct torture_context *tctx, struct winreg_DeleteKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 366 {
 367         torture_assert_werr_equal(tctx, r->out.result, WERR_BADFILE, "return code");
 368         return true;
 369 }
 370 
 371 static const uint8_t getversion_in_data[] = {
 372   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
 373   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3
 374 };
 375 
 376 static bool getversion_in_check(struct torture_context *tctx, struct winreg_GetVersion *r)
     /* [<][>][^][v][top][bottom][index][help] */
 377 {
 378         /* FIXME: Handle */
 379         return true;
 380 }
 381 
 382 static const uint8_t getversion_out_data[] = {
 383   0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 384 };
 385 
 386 static bool getversion_out_check(struct torture_context *tctx, struct winreg_GetVersion *r)
     /* [<][>][^][v][top][bottom][index][help] */
 387 {
 388         torture_assert_int_equal(tctx, *r->out.version, 5, "version");
 389         torture_assert_werr_ok(tctx, r->out.result, "return code");
 390         return true;
 391 }
 392 
 393 static const uint8_t queryinfokey_in_data[] = {
 394   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
 395   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x00, 0x00, 0x00, 0x00,
 396   0x00, 0x00, 0x00, 0x00
 397 };
 398 
 399 static bool queryinfokey_in_check(struct torture_context *tctx, struct winreg_QueryInfoKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 400 {
 401         /* FIXME: Handle */
 402         torture_assert(tctx, r->in.classname->name == NULL, "class in");
 403         return true;
 404 }
 405 
 406 static const uint8_t queryinfokey_out_data[] = {
 407   0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 408   0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 409   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00,
 410   0x10, 0x48, 0x02, 0x3a, 0xcf, 0xfd, 0xc4, 0x01, 0x00, 0x00, 0x00, 0x00
 411 };
 412 
 413 static bool queryinfokey_out_check(struct torture_context *tctx, struct winreg_QueryInfoKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 414 {
 415         torture_assert(tctx, r->out.classname != NULL, "class out");
 416         torture_assert(tctx, r->out.classname->name != NULL, "class out name");
 417         torture_assert_str_equal(tctx, r->out.classname->name, "", "class out name");
 418         torture_assert_int_equal(tctx, *r->out.num_subkeys, 0, "num subkeys");
 419         torture_assert_int_equal(tctx, *r->out.max_subkeylen, 0, "subkey length");
 420         torture_assert_int_equal(tctx, *r->out.max_classlen, 140, "subkey size");
 421         torture_assert_werr_ok(tctx, r->out.result, "return code");
 422         return true;
 423 }
 424 
 425 static const uint8_t notifychangekeyvalue_in_data[] = {
 426   0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
 427   0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x01, 0x00, 0x00, 0x00,
 428   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 429   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 430   0x00, 0x00, 0x00, 0x00
 431 };
 432 
 433 static bool notifychangekeyvalue_in_check(struct torture_context *tctx, struct winreg_NotifyChangeKeyValue *r)
     /* [<][>][^][v][top][bottom][index][help] */
 434 {
 435         torture_assert_int_equal(tctx, r->in.watch_subtree, 1, "watch subtree");
 436         torture_assert_int_equal(tctx, r->in.notify_filter, 0, "notify filter");
 437         torture_assert_int_equal(tctx, r->in.unknown, 0, "unknown");
 438         torture_assert(tctx, r->in.string1.name == NULL, "string1");
 439         torture_assert(tctx, r->in.string2.name == NULL, "string2");
 440         torture_assert_int_equal(tctx, r->in.unknown2, 0, "unknown2");
 441         return true;
 442 }
 443 
 444 static const uint8_t notifychangekeyvalue_out_data[] = {
 445   0x57, 0x00, 0x00, 0x00
 446 };
 447 
 448 static bool notifychangekeyvalue_out_check(struct torture_context *tctx, struct winreg_NotifyChangeKeyValue *r)
     /* [<][>][^][v][top][bottom][index][help] */
 449 {
 450         torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "notify change key value");
 451         return true;
 452 }
 453 
 454 static const uint8_t getkeysecurity_in_data[] = {
 455   0x00, 0x00, 0x00, 0x00, 0xbd, 0xaa, 0xf6, 0x59, 0xc1, 0x82, 0x1f, 0x4d,
 456   0x84, 0xa9, 0xdd, 0xae, 0x60, 0x77, 0x1e, 0x45, 0x00, 0x00, 0x00, 0x02,
 457   0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 458 };
 459 
 460 static bool getkeysecurity_in_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 461                                     struct winreg_GetKeySecurity *r)
 462 {
 463         /* FIXME: Handle */
 464         torture_assert_int_equal(tctx, r->in.sec_info, 2, "sec info");
 465         torture_assert_int_equal(tctx, r->in.sd->size, 65536, "sd size");
 466         torture_assert_int_equal(tctx, r->in.sd->len, 0, "sd len");
 467         torture_assert(tctx, r->in.sd->data == NULL, "sd data");
 468         return true;
 469 }
 470 
 471 static const uint8_t getkeysecurity_out_data[] = {
 472   0x08, 0x91, 0x08, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
 473   0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
 474   0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 475   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 476 };
 477 
 478 static bool getkeysecurity_out_check(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 479                                      struct winreg_GetKeySecurity *r)
 480 {
 481         torture_assert_int_equal(tctx, r->in.sd->size, 20, "sd size");
 482         torture_assert_int_equal(tctx, r->in.sd->len, 20, "sd len");
 483         torture_assert_werr_ok(tctx, r->out.result, "return code");
 484         return true;
 485 }
 486 
 487 static const uint8_t enumkey_in_data[] = {
 488   0x00, 0x00, 0x00, 0x00, 0x85, 0xb8, 0x41, 0xb0, 0x17, 0xe4, 0x28, 0x45,
 489   0x8a, 0x69, 0xbf, 0x40, 0x79, 0x82, 0x8b, 0xcb, 0x00, 0x00, 0x00, 0x00,
 490   0x00, 0x00, 0x14, 0x04, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x02, 0x00, 0x00,
 491   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 492   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
 493   0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f
 494 };
 495 
 496 static bool enumkey_in_check(struct torture_context *tctx, struct winreg_EnumKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 497 {
 498         torture_assert_int_equal(tctx, r->in.enum_index, 0, "enum index");
 499         torture_assert_int_equal(tctx, r->in.name->size, 1044, "name size");
 500         torture_assert_int_equal(tctx, r->in.name->length, 0, "name len");
 501         torture_assert(tctx, r->in.keyclass != NULL, "keyclass pointer");
 502         torture_assert(tctx, r->in.keyclass->name == NULL, "keyclass");
 503         torture_assert(tctx, r->in.last_changed_time != NULL, "last_changed_time != NULL");
 504         return true;
 505 }
 506 
 507 static const uint8_t enumkey_out_data[] = {
 508   0x08, 0x00, 0x14, 0x04, 0x18, 0xe8, 0x07, 0x00, 0x0a, 0x02, 0x00, 0x00,
 509   0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x53, 0x00, 0x41, 0x00,
 510   0x4d, 0x00, 0x00, 0x00, 0xd0, 0x62, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
 511   0x00, 0x00, 0x00, 0x00, 0xdc, 0x62, 0x07, 0x00, 0x50, 0x67, 0xd0, 0x8b,
 512   0x16, 0x06, 0xc2, 0x01, 0x00, 0x00, 0x00, 0x00
 513 };
 514 
 515 static bool enumkey_out_check(struct torture_context *tctx, struct winreg_EnumKey *r)
     /* [<][>][^][v][top][bottom][index][help] */
 516 {
 517         torture_assert_int_equal(tctx, r->out.name->size, 1044, "name size");
 518         torture_assert_int_equal(tctx, r->out.name->length, 8, "name len");
 519         torture_assert(tctx, r->out.keyclass != NULL, "keyclass pointer");
 520         torture_assert(tctx, r->out.keyclass->name == NULL, "keyclass");
 521         torture_assert(tctx, r->out.last_changed_time != NULL, "last_changed_time pointer");
 522         /* FIXME: *last_changed_time */
 523         return true;
 524 }
 525 
 526 struct torture_suite *ndr_winreg_suite(TALLOC_CTX *ctx)
     /* [<][>][^][v][top][bottom][index][help] */
 527 {
 528         struct torture_suite *suite = torture_suite_create(ctx, "winreg");
 529 
 530         torture_suite_add_ndr_pull_fn_test(suite, winreg_CloseKey, closekey_in_data, NDR_IN, closekey_in_check );
 531         torture_suite_add_ndr_pull_fn_test(suite, winreg_CloseKey, closekey_out_data, NDR_OUT, closekey_out_check );
 532 
 533         torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenHKLM, OpenHKLM_In, NDR_IN, openhklm_in_check );
 534         torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenHKLM, openhklm_out_data, NDR_OUT, openhklm_out_check );
 535 
 536         torture_suite_add_ndr_pull_fn_test(suite, winreg_CreateKey, createkey_in_data, NDR_IN, createkey_in_check );
 537         torture_suite_add_ndr_pull_fn_test(suite, winreg_CreateKey, createkey_out_data, NDR_OUT, createkey_out_check );
 538 
 539         torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumValue, enumvalue_in_data, NDR_IN, enumvalue_in_check );
 540         torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumValue, enumvalue_out_data, NDR_OUT, enumvalue_out_check );
 541         torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumValue, enumvalue_in_data2, NDR_IN, NULL);
 542 
 543         torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryValue, queryvalue_in_data, NDR_IN, queryvalue_in_check );
 544         torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryValue, queryvalue_out_data, NDR_OUT, queryvalue_out_check );
 545 
 546         /*torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryMultipleValues, querymultiplevalues_in_data, NDR_IN, querymultiplevalues_in_check );
 547         torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryMultipleValues, querymultiplevalues_out_data, NDR_OUT, querymultiplevalues_out_check );*/
 548 
 549         torture_suite_add_ndr_pull_fn_test(suite, winreg_FlushKey, flushkey_in_data, NDR_IN, flushkey_in_check );
 550         torture_suite_add_ndr_pull_fn_test(suite, winreg_FlushKey, flushkey_out_data, NDR_OUT, flushkey_out_check );
 551 
 552         torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenKey, openkey_in_data, NDR_IN, openkey_in_check );
 553         torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenKey, openkey_out_data, NDR_OUT, openkey_out_check );
 554 
 555         torture_suite_add_ndr_pull_fn_test(suite, winreg_DeleteKey, deletekey_in_data, NDR_IN, deletekey_in_check );
 556         torture_suite_add_ndr_pull_fn_test(suite, winreg_DeleteKey, deletekey_out_data, NDR_OUT, deletekey_out_check );
 557 
 558         torture_suite_add_ndr_pull_fn_test(suite, winreg_GetVersion, getversion_in_data, NDR_IN, getversion_in_check );
 559         torture_suite_add_ndr_pull_fn_test(suite, winreg_GetVersion, getversion_out_data, NDR_OUT, getversion_out_check );
 560 
 561         torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryInfoKey, queryinfokey_in_data, NDR_IN, queryinfokey_in_check );
 562         /*torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryInfoKey, queryinfokey_out_data, NDR_OUT, queryinfokey_out_check );*/
 563 
 564         torture_suite_add_ndr_pull_fn_test(suite, winreg_NotifyChangeKeyValue, notifychangekeyvalue_in_data, NDR_IN, notifychangekeyvalue_in_check );
 565         torture_suite_add_ndr_pull_fn_test(suite, winreg_NotifyChangeKeyValue, notifychangekeyvalue_out_data, NDR_OUT, notifychangekeyvalue_out_check );
 566 
 567         /*torture_suite_add_ndr_pull_fn_test(suite, winreg_GetKeySecurity, getkeysecurity_in_data, NDR_IN, getkeysecurity_in_check );
 568         torture_suite_add_ndr_pull_fn_test(suite, winreg_GetKeySecurity, getkeysecurity_out_data, NDR_OUT, getkeysecurity_out_check );*/
 569 
 570         torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumKey, enumkey_in_data, NDR_IN, enumkey_in_check );
 571         torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumKey, enumkey_out_data, NDR_OUT, enumkey_out_check );
 572 
 573         return suite;
 574 }
 575 

/* [<][>][^][v][top][bottom][index][help] */