source3/librpc/gen_ndr/ndr_winreg.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_winreg.h"
   5
   6 #include "librpc/gen_ndr/ndr_lsa.h"
   7 #include "librpc/gen_ndr/ndr_initshutdown.h"
   8 #include "librpc/gen_ndr/ndr_security.h"
   9 NTSTATUS ndr_push_winreg_AccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  10 {
  11         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  12         return NT_STATUS_OK;
  13 }
  14
  15 NTSTATUS ndr_pull_winreg_AccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  16 {
  17         uint32_t v;
  18         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  19         *r = v;
  20         return NT_STATUS_OK;
  21 }
  22
  23 _PUBLIC_ void ndr_print_winreg_AccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
  24 {
  25         ndr_print_uint32(ndr, name, r);
  26         ndr->depth++;
  27         ndr->depth--;
  28 }
  29
  30 NTSTATUS ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r)
  31 {
  32         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  33         return NT_STATUS_OK;
  34 }
  35
  36 NTSTATUS ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r)
  37 {
  38         uint32_t v;
  39         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  40         *r = v;
  41         return NT_STATUS_OK;
  42 }
  43
  44 _PUBLIC_ void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r)
  45 {
  46         const char *val = NULL;
  47
  48         switch (r) {
  49                 case REG_NONE: val = "REG_NONE"; break;
  50                 case REG_SZ: val = "REG_SZ"; break;
  51                 case REG_EXPAND_SZ: val = "REG_EXPAND_SZ"; break;
  52                 case REG_BINARY: val = "REG_BINARY"; break;
  53                 case REG_DWORD: val = "REG_DWORD"; break;
  54                 case REG_DWORD_BIG_ENDIAN: val = "REG_DWORD_BIG_ENDIAN"; break;
  55                 case REG_LINK: val = "REG_LINK"; break;
  56                 case REG_MULTI_SZ: val = "REG_MULTI_SZ"; break;
  57                 case REG_RESOURCE_LIST: val = "REG_RESOURCE_LIST"; break;
  58                 case REG_FULL_RESOURCE_DESCRIPTOR: val = "REG_FULL_RESOURCE_DESCRIPTOR"; break;
  59                 case REG_RESOURCE_REQUIREMENTS_LIST: val = "REG_RESOURCE_REQUIREMENTS_LIST"; break;
  60                 case REG_QWORD: val = "REG_QWORD"; break;
  61         }
  62         ndr_print_enum(ndr, name, "ENUM", val, r);
  63 }
  64
  65 _PUBLIC_ NTSTATUS ndr_push_winreg_String(struct ndr_push *ndr, int ndr_flags, const struct winreg_String *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name)*2));
  70                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name)*2));
  71                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
  72         }
  73         if (ndr_flags & NDR_BUFFERS) {
  74                 if (r->name) {
  75                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
  76                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  77                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
  78                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  79                 }
  80         }
  81         return NT_STATUS_OK;
  82 }
  83
  84 _PUBLIC_ NTSTATUS ndr_pull_winreg_String(struct ndr_pull *ndr, int ndr_flags, struct winreg_String *r)
  85 {
  86         uint32_t _ptr_name;
  87         TALLOC_CTX *_mem_save_name_0;
  88         if (ndr_flags & NDR_SCALARS) {
  89                 NDR_CHECK(ndr_pull_align(ndr, 4));
  90                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
  91                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_size));
  92                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
  93                 if (_ptr_name) {
  94                         NDR_PULL_ALLOC(ndr, r->name);
  95                 } else {
  96                         r->name = NULL;
  97                 }
  98         }
  99         if (ndr_flags & NDR_BUFFERS) {
 100                 if (r->name) {
 101                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 102                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
 104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
 105                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
 106                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
 107                         }
 108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
 109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
 110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 111                 }
 112         }
 113         return NT_STATUS_OK;
 114 }
 115
 116 _PUBLIC_ void ndr_print_winreg_String(struct ndr_print *ndr, const char *name, const struct winreg_String *r)
 117 {
 118         ndr_print_struct(ndr, name, "winreg_String");
 119         ndr->depth++;
 120         ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name)*2:r->name_len);
 121         ndr_print_uint16(ndr, "name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name)*2:r->name_size);
 122         ndr_print_ptr(ndr, "name", r->name);
 123         ndr->depth++;
 124         if (r->name) {
 125                 ndr_print_string(ndr, "name", r->name);
 126         }
 127         ndr->depth--;
 128         ndr->depth--;
 129 }
 130
 131 NTSTATUS ndr_push_KeySecurityData(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityData *r)
 132 {
 133         if (ndr_flags & NDR_SCALARS) {
 134                 NDR_CHECK(ndr_push_align(ndr, 4));
 135                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
 136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 138         }
 139         if (ndr_flags & NDR_BUFFERS) {
 140                 if (r->data) {
 141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 144                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->len));
 145                 }
 146         }
 147         return NT_STATUS_OK;
 148 }
 149
 150 NTSTATUS ndr_pull_KeySecurityData(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityData *r)
 151 {
 152         uint32_t _ptr_data;
 153         TALLOC_CTX *_mem_save_data_0;
 154         if (ndr_flags & NDR_SCALARS) {
 155                 NDR_CHECK(ndr_pull_align(ndr, 4));
 156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
 157                 if (_ptr_data) {
 158                         NDR_PULL_ALLOC(ndr, r->data);
 159                 } else {
 160                         r->data = NULL;
 161                 }
 162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 164         }
 165         if (ndr_flags & NDR_BUFFERS) {
 166                 if (r->data) {
 167                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 168                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
 169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
 170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
 171                         if (ndr_get_array_length(ndr, &r->data) > ndr_get_array_size(ndr, &r->data)) {
 172                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data), ndr_get_array_length(ndr, &r->data));
 173                         }
 174                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
 175                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_length(ndr, &r->data)));
 176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
 177                 }
 178                 if (r->data) {
 179                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
 180                 }
 181                 if (r->data) {
 182                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->len));
 183                 }
 184         }
 185         return NT_STATUS_OK;
 186 }
 187
 188 _PUBLIC_ void ndr_print_KeySecurityData(struct ndr_print *ndr, const char *name, const struct KeySecurityData *r)
 189 {
 190         ndr_print_struct(ndr, name, "KeySecurityData");
 191         ndr->depth++;
 192         ndr_print_ptr(ndr, "data", r->data);
 193         ndr->depth++;
 194         if (r->data) {
 195                 ndr_print_array_uint8(ndr, "data", r->data, r->len);
 196         }
 197         ndr->depth--;
 198         ndr_print_uint32(ndr, "size", r->size);
 199         ndr_print_uint32(ndr, "len", r->len);
 200         ndr->depth--;
 201 }
 202
 203 NTSTATUS ndr_push_winreg_SecBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_SecBuf *r)
 204 {
 205         if (ndr_flags & NDR_SCALARS) {
 206                 NDR_CHECK(ndr_push_align(ndr, 4));
 207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 208                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
 209                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
 210         }
 211         if (ndr_flags & NDR_BUFFERS) {
 212                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
 213         }
 214         return NT_STATUS_OK;
 215 }
 216
 217 NTSTATUS ndr_pull_winreg_SecBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_SecBuf *r)
 218 {
 219         if (ndr_flags & NDR_SCALARS) {
 220                 NDR_CHECK(ndr_pull_align(ndr, 4));
 221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 222                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
 223                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
 224         }
 225         if (ndr_flags & NDR_BUFFERS) {
 226                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
 227         }
 228         return NT_STATUS_OK;
 229 }
 230
 231 _PUBLIC_ void ndr_print_winreg_SecBuf(struct ndr_print *ndr, const char *name, const struct winreg_SecBuf *r)
 232 {
 233         ndr_print_struct(ndr, name, "winreg_SecBuf");
 234         ndr->depth++;
 235         ndr_print_uint32(ndr, "length", r->length);
 236         ndr_print_KeySecurityData(ndr, "sd", &r->sd);
 237         ndr_print_uint8(ndr, "inherit", r->inherit);
 238         ndr->depth--;
 239 }
 240
 241 NTSTATUS ndr_push_winreg_CreateAction(struct ndr_push *ndr, int ndr_flags, enum winreg_CreateAction r)
 242 {
 243         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 244         return NT_STATUS_OK;
 245 }
 246
 247 NTSTATUS ndr_pull_winreg_CreateAction(struct ndr_pull *ndr, int ndr_flags, enum winreg_CreateAction *r)
 248 {
 249         uint32_t v;
 250         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 251         *r = v;
 252         return NT_STATUS_OK;
 253 }
 254
 255 _PUBLIC_ void ndr_print_winreg_CreateAction(struct ndr_print *ndr, const char *name, enum winreg_CreateAction r)
 256 {
 257         const char *val = NULL;
 258
 259         switch (r) {
 260                 case REG_ACTION_NONE: val = "REG_ACTION_NONE"; break;
 261                 case REG_CREATED_NEW_KEY: val = "REG_CREATED_NEW_KEY"; break;
 262                 case REG_OPENED_EXISTING_KEY: val = "REG_OPENED_EXISTING_KEY"; break;
 263         }
 264         ndr_print_enum(ndr, name, "ENUM", val, r);
 265 }
 266
 267 NTSTATUS ndr_push_winreg_StringBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_StringBuf *r)
 268 {
 269         if (ndr_flags & NDR_SCALARS) {
 270                 NDR_CHECK(ndr_push_align(ndr, 4));
 271                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name)*2));
 272                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
 274         }
 275         if (ndr_flags & NDR_BUFFERS) {
 276                 if (r->name) {
 277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size/2));
 278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term(r->name)*2/2));
 280                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term(r->name)*2/2, sizeof(uint16_t), CH_UTF16));
 281                 }
 282         }
 283         return NT_STATUS_OK;
 284 }
 285
 286 NTSTATUS ndr_pull_winreg_StringBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_StringBuf *r)
 287 {
 288         uint32_t _ptr_name;
 289         TALLOC_CTX *_mem_save_name_0;
 290         if (ndr_flags & NDR_SCALARS) {
 291                 NDR_CHECK(ndr_pull_align(ndr, 4));
 292                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 293                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 295                 if (_ptr_name) {
 296                         NDR_PULL_ALLOC(ndr, r->name);
 297                 } else {
 298                         r->name = NULL;
 299                 }
 300         }
 301         if (ndr_flags & NDR_BUFFERS) {
 302                 if (r->name) {
 303                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 304                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
 306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
 307                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
 308                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
 309                         }
 310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
 311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 312                 }
 313                 if (r->name) {
 314                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->name, r->size/2));
 315                 }
 316                 if (r->name) {
 317                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->name, r->length/2));
 318                 }
 319         }
 320         return NT_STATUS_OK;
 321 }
 322
 323 _PUBLIC_ void ndr_print_winreg_StringBuf(struct ndr_print *ndr, const char *name, const struct winreg_StringBuf *r)
 324 {
 325         ndr_print_struct(ndr, name, "winreg_StringBuf");
 326         ndr->depth++;
 327         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name)*2:r->length);
 328         ndr_print_uint16(ndr, "size", r->size);
 329         ndr_print_ptr(ndr, "name", r->name);
 330         ndr->depth++;
 331         if (r->name) {
 332                 ndr_print_string(ndr, "name", r->name);
 333         }
 334         ndr->depth--;
 335         ndr->depth--;
 336 }
 337
 338 NTSTATUS ndr_push_KeySecurityAttribute(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityAttribute *r)
 339 {
 340         if (ndr_flags & NDR_SCALARS) {
 341                 NDR_CHECK(ndr_push_align(ndr, 4));
 342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_size));
 343                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
 344                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
 345         }
 346         if (ndr_flags & NDR_BUFFERS) {
 347                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
 348         }
 349         return NT_STATUS_OK;
 350 }
 351
 352 NTSTATUS ndr_pull_KeySecurityAttribute(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityAttribute *r)
 353 {
 354         if (ndr_flags & NDR_SCALARS) {
 355                 NDR_CHECK(ndr_pull_align(ndr, 4));
 356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_size));
 357                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
 358                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
 359         }
 360         if (ndr_flags & NDR_BUFFERS) {
 361                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
 362         }
 363         return NT_STATUS_OK;
 364 }
 365
 366 _PUBLIC_ void ndr_print_KeySecurityAttribute(struct ndr_print *ndr, const char *name, const struct KeySecurityAttribute *r)
 367 {
 368         ndr_print_struct(ndr, name, "KeySecurityAttribute");
 369         ndr->depth++;
 370         ndr_print_uint32(ndr, "data_size", r->data_size);
 371         ndr_print_KeySecurityData(ndr, "sec_data", &r->sec_data);
 372         ndr_print_uint8(ndr, "inherit", r->inherit);
 373         ndr->depth--;
 374 }
 375
 376 NTSTATUS ndr_push_QueryMultipleValue(struct ndr_push *ndr, int ndr_flags, const struct QueryMultipleValue *r)
 377 {
 378         if (ndr_flags & NDR_SCALARS) {
 379                 NDR_CHECK(ndr_push_align(ndr, 4));
 380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
 381                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
 382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->offset));
 383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 384         }
 385         if (ndr_flags & NDR_BUFFERS) {
 386                 if (r->name) {
 387                         NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->name));
 388                 }
 389         }
 390         return NT_STATUS_OK;
 391 }
 392
 393 NTSTATUS ndr_pull_QueryMultipleValue(struct ndr_pull *ndr, int ndr_flags, struct QueryMultipleValue *r)
 394 {
 395         uint32_t _ptr_name;
 396         TALLOC_CTX *_mem_save_name_0;
 397         if (ndr_flags & NDR_SCALARS) {
 398                 NDR_CHECK(ndr_pull_align(ndr, 4));
 399                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 400                 if (_ptr_name) {
 401                         NDR_PULL_ALLOC(ndr, r->name);
 402                 } else {
 403                         r->name = NULL;
 404                 }
 405                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->offset));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 408         }
 409         if (ndr_flags & NDR_BUFFERS) {
 410                 if (r->name) {
 411                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 412                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 413                         NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->name));
 414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 415                 }
 416         }
 417         return NT_STATUS_OK;
 418 }
 419
 420 _PUBLIC_ void ndr_print_QueryMultipleValue(struct ndr_print *ndr, const char *name, const struct QueryMultipleValue *r)
 421 {
 422         ndr_print_struct(ndr, name, "QueryMultipleValue");
 423         ndr->depth++;
 424         ndr_print_ptr(ndr, "name", r->name);
 425         ndr->depth++;
 426         if (r->name) {
 427                 ndr_print_winreg_String(ndr, "name", r->name);
 428         }
 429         ndr->depth--;
 430         ndr_print_winreg_Type(ndr, "type", r->type);
 431         ndr_print_uint32(ndr, "offset", r->offset);
 432         ndr_print_uint32(ndr, "length", r->length);
 433         ndr->depth--;
 434 }
 435
 436 NTSTATUS ndr_push_winreg_OpenHKCR(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCR *r)
 437 {
 438         if (flags & NDR_IN) {
 439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 440                 if (r->in.system_name) {
 441                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 442                 }
 443                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 444         }
 445         if (flags & NDR_OUT) {
 446                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 447                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 448                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 449         }
 450         return NT_STATUS_OK;
 451 }
 452
 453 NTSTATUS ndr_pull_winreg_OpenHKCR(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCR *r)
 454 {
 455         uint32_t _ptr_system_name;
 456         TALLOC_CTX *_mem_save_system_name_0;
 457         TALLOC_CTX *_mem_save_handle_0;
 458         if (flags & NDR_IN) {
 459                 ZERO_STRUCT(r->out);
 460
 461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 462                 if (_ptr_system_name) {
 463                         NDR_PULL_ALLOC(ndr, r->in.system_name);
 464                 } else {
 465                         r->in.system_name = NULL;
 466                 }
 467                 if (r->in.system_name) {
 468                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 469                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 470                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 472                 }
 473                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 474                 NDR_PULL_ALLOC(ndr, r->out.handle);
 475                 ZERO_STRUCTP(r->out.handle);
 476         }
 477         if (flags & NDR_OUT) {
 478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 479                         NDR_PULL_ALLOC(ndr, r->out.handle);
 480                 }
 481                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 482                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 483                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 485                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 486         }
 487         return NT_STATUS_OK;
 488 }
 489
 490 _PUBLIC_ void ndr_print_winreg_OpenHKCR(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCR *r)
 491 {
 492         ndr_print_struct(ndr, name, "winreg_OpenHKCR");
 493         ndr->depth++;
 494         if (flags & NDR_SET_VALUES) {
 495                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 496         }
 497         if (flags & NDR_IN) {
 498                 ndr_print_struct(ndr, "in", "winreg_OpenHKCR");
 499                 ndr->depth++;
 500                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
 501                 ndr->depth++;
 502                 if (r->in.system_name) {
 503                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 504                 }
 505                 ndr->depth--;
 506                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
 507                 ndr->depth--;
 508         }
 509         if (flags & NDR_OUT) {
 510                 ndr_print_struct(ndr, "out", "winreg_OpenHKCR");
 511                 ndr->depth++;
 512                 ndr_print_ptr(ndr, "handle", r->out.handle);
 513                 ndr->depth++;
 514                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 515                 ndr->depth--;
 516                 ndr_print_WERROR(ndr, "result", r->out.result);
 517                 ndr->depth--;
 518         }
 519         ndr->depth--;
 520 }
 521
 522 NTSTATUS ndr_push_winreg_OpenHKCU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCU *r)
 523 {
 524         if (flags & NDR_IN) {
 525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 526                 if (r->in.system_name) {
 527                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 528                 }
 529                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 530         }
 531         if (flags & NDR_OUT) {
 532                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 533                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 535         }
 536         return NT_STATUS_OK;
 537 }
 538
 539 NTSTATUS ndr_pull_winreg_OpenHKCU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCU *r)
 540 {
 541         uint32_t _ptr_system_name;
 542         TALLOC_CTX *_mem_save_system_name_0;
 543         TALLOC_CTX *_mem_save_handle_0;
 544         if (flags & NDR_IN) {
 545                 ZERO_STRUCT(r->out);
 546
 547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 548                 if (_ptr_system_name) {
 549                         NDR_PULL_ALLOC(ndr, r->in.system_name);
 550                 } else {
 551                         r->in.system_name = NULL;
 552                 }
 553                 if (r->in.system_name) {
 554                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 555                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 556                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 558                 }
 559                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 560                 NDR_PULL_ALLOC(ndr, r->out.handle);
 561                 ZERO_STRUCTP(r->out.handle);
 562         }
 563         if (flags & NDR_OUT) {
 564                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 565                         NDR_PULL_ALLOC(ndr, r->out.handle);
 566                 }
 567                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 568                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 569                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 570                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 571                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 572         }
 573         return NT_STATUS_OK;
 574 }
 575
 576 _PUBLIC_ void ndr_print_winreg_OpenHKCU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCU *r)
 577 {
 578         ndr_print_struct(ndr, name, "winreg_OpenHKCU");
 579         ndr->depth++;
 580         if (flags & NDR_SET_VALUES) {
 581                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 582         }
 583         if (flags & NDR_IN) {
 584                 ndr_print_struct(ndr, "in", "winreg_OpenHKCU");
 585                 ndr->depth++;
 586                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
 587                 ndr->depth++;
 588                 if (r->in.system_name) {
 589                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 590                 }
 591                 ndr->depth--;
 592                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
 593                 ndr->depth--;
 594         }
 595         if (flags & NDR_OUT) {
 596                 ndr_print_struct(ndr, "out", "winreg_OpenHKCU");
 597                 ndr->depth++;
 598                 ndr_print_ptr(ndr, "handle", r->out.handle);
 599                 ndr->depth++;
 600                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 601                 ndr->depth--;
 602                 ndr_print_WERROR(ndr, "result", r->out.result);
 603                 ndr->depth--;
 604         }
 605         ndr->depth--;
 606 }
 607
 608 NTSTATUS ndr_push_winreg_OpenHKLM(struct ndr_push *ndr, int flags, const struct winreg_OpenHKLM *r)
 609 {
 610         if (flags & NDR_IN) {
 611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 612                 if (r->in.system_name) {
 613                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 614                 }
 615                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 616         }
 617         if (flags & NDR_OUT) {
 618                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 619                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 621         }
 622         return NT_STATUS_OK;
 623 }
 624
 625 NTSTATUS ndr_pull_winreg_OpenHKLM(struct ndr_pull *ndr, int flags, struct winreg_OpenHKLM *r)
 626 {
 627         uint32_t _ptr_system_name;
 628         TALLOC_CTX *_mem_save_system_name_0;
 629         TALLOC_CTX *_mem_save_handle_0;
 630         if (flags & NDR_IN) {
 631                 ZERO_STRUCT(r->out);
 632
 633                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 634                 if (_ptr_system_name) {
 635                         NDR_PULL_ALLOC(ndr, r->in.system_name);
 636                 } else {
 637                         r->in.system_name = NULL;
 638                 }
 639                 if (r->in.system_name) {
 640                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 641                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 642                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 643                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 644                 }
 645                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 646                 NDR_PULL_ALLOC(ndr, r->out.handle);
 647                 ZERO_STRUCTP(r->out.handle);
 648         }
 649         if (flags & NDR_OUT) {
 650                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 651                         NDR_PULL_ALLOC(ndr, r->out.handle);
 652                 }
 653                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 654                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 655                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 656                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 657                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 658         }
 659         return NT_STATUS_OK;
 660 }
 661
 662 _PUBLIC_ void ndr_print_winreg_OpenHKLM(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKLM *r)
 663 {
 664         ndr_print_struct(ndr, name, "winreg_OpenHKLM");
 665         ndr->depth++;
 666         if (flags & NDR_SET_VALUES) {
 667                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 668         }
 669         if (flags & NDR_IN) {
 670                 ndr_print_struct(ndr, "in", "winreg_OpenHKLM");
 671                 ndr->depth++;
 672                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
 673                 ndr->depth++;
 674                 if (r->in.system_name) {
 675                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 676                 }
 677                 ndr->depth--;
 678                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
 679                 ndr->depth--;
 680         }
 681         if (flags & NDR_OUT) {
 682                 ndr_print_struct(ndr, "out", "winreg_OpenHKLM");
 683                 ndr->depth++;
 684                 ndr_print_ptr(ndr, "handle", r->out.handle);
 685                 ndr->depth++;
 686                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 687                 ndr->depth--;
 688                 ndr_print_WERROR(ndr, "result", r->out.result);
 689                 ndr->depth--;
 690         }
 691         ndr->depth--;
 692 }
 693
 694 NTSTATUS ndr_push_winreg_OpenHKPD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPD *r)
 695 {
 696         if (flags & NDR_IN) {
 697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 698                 if (r->in.system_name) {
 699                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 700                 }
 701                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 702         }
 703         if (flags & NDR_OUT) {
 704                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 706                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 707         }
 708         return NT_STATUS_OK;
 709 }
 710
 711 NTSTATUS ndr_pull_winreg_OpenHKPD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPD *r)
 712 {
 713         uint32_t _ptr_system_name;
 714         TALLOC_CTX *_mem_save_system_name_0;
 715         TALLOC_CTX *_mem_save_handle_0;
 716         if (flags & NDR_IN) {
 717                 ZERO_STRUCT(r->out);
 718
 719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 720                 if (_ptr_system_name) {
 721                         NDR_PULL_ALLOC(ndr, r->in.system_name);
 722                 } else {
 723                         r->in.system_name = NULL;
 724                 }
 725                 if (r->in.system_name) {
 726                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 727                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 728                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 730                 }
 731                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 732                 NDR_PULL_ALLOC(ndr, r->out.handle);
 733                 ZERO_STRUCTP(r->out.handle);
 734         }
 735         if (flags & NDR_OUT) {
 736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 737                         NDR_PULL_ALLOC(ndr, r->out.handle);
 738                 }
 739                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 740                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 741                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 743                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 744         }
 745         return NT_STATUS_OK;
 746 }
 747
 748 _PUBLIC_ void ndr_print_winreg_OpenHKPD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPD *r)
 749 {
 750         ndr_print_struct(ndr, name, "winreg_OpenHKPD");
 751         ndr->depth++;
 752         if (flags & NDR_SET_VALUES) {
 753                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 754         }
 755         if (flags & NDR_IN) {
 756                 ndr_print_struct(ndr, "in", "winreg_OpenHKPD");
 757                 ndr->depth++;
 758                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
 759                 ndr->depth++;
 760                 if (r->in.system_name) {
 761                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 762                 }
 763                 ndr->depth--;
 764                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
 765                 ndr->depth--;
 766         }
 767         if (flags & NDR_OUT) {
 768                 ndr_print_struct(ndr, "out", "winreg_OpenHKPD");
 769                 ndr->depth++;
 770                 ndr_print_ptr(ndr, "handle", r->out.handle);
 771                 ndr->depth++;
 772                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 773                 ndr->depth--;
 774                 ndr_print_WERROR(ndr, "result", r->out.result);
 775                 ndr->depth--;
 776         }
 777         ndr->depth--;
 778 }
 779
 780 NTSTATUS ndr_push_winreg_OpenHKU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKU *r)
 781 {
 782         if (flags & NDR_IN) {
 783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 784                 if (r->in.system_name) {
 785                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 786                 }
 787                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 788         }
 789         if (flags & NDR_OUT) {
 790                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 791                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 793         }
 794         return NT_STATUS_OK;
 795 }
 796
 797 NTSTATUS ndr_pull_winreg_OpenHKU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKU *r)
 798 {
 799         uint32_t _ptr_system_name;
 800         TALLOC_CTX *_mem_save_system_name_0;
 801         TALLOC_CTX *_mem_save_handle_0;
 802         if (flags & NDR_IN) {
 803                 ZERO_STRUCT(r->out);
 804
 805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 806                 if (_ptr_system_name) {
 807                         NDR_PULL_ALLOC(ndr, r->in.system_name);
 808                 } else {
 809                         r->in.system_name = NULL;
 810                 }
 811                 if (r->in.system_name) {
 812                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 813                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 814                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 816                 }
 817                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 818                 NDR_PULL_ALLOC(ndr, r->out.handle);
 819                 ZERO_STRUCTP(r->out.handle);
 820         }
 821         if (flags & NDR_OUT) {
 822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 823                         NDR_PULL_ALLOC(ndr, r->out.handle);
 824                 }
 825                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 826                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 827                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 829                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 830         }
 831         return NT_STATUS_OK;
 832 }
 833
 834 _PUBLIC_ void ndr_print_winreg_OpenHKU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKU *r)
 835 {
 836         ndr_print_struct(ndr, name, "winreg_OpenHKU");
 837         ndr->depth++;
 838         if (flags & NDR_SET_VALUES) {
 839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 840         }
 841         if (flags & NDR_IN) {
 842                 ndr_print_struct(ndr, "in", "winreg_OpenHKU");
 843                 ndr->depth++;
 844                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
 845                 ndr->depth++;
 846                 if (r->in.system_name) {
 847                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 848                 }
 849                 ndr->depth--;
 850                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
 851                 ndr->depth--;
 852         }
 853         if (flags & NDR_OUT) {
 854                 ndr_print_struct(ndr, "out", "winreg_OpenHKU");
 855                 ndr->depth++;
 856                 ndr_print_ptr(ndr, "handle", r->out.handle);
 857                 ndr->depth++;
 858                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 859                 ndr->depth--;
 860                 ndr_print_WERROR(ndr, "result", r->out.result);
 861                 ndr->depth--;
 862         }
 863         ndr->depth--;
 864 }
 865
 866 NTSTATUS ndr_push_winreg_CloseKey(struct ndr_push *ndr, int flags, const struct winreg_CloseKey *r)
 867 {
 868         if (flags & NDR_IN) {
 869                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 870                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 871         }
 872         if (flags & NDR_OUT) {
 873                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 874                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 875                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 876         }
 877         return NT_STATUS_OK;
 878 }
 879
 880 NTSTATUS ndr_pull_winreg_CloseKey(struct ndr_pull *ndr, int flags, struct winreg_CloseKey *r)
 881 {
 882         TALLOC_CTX *_mem_save_handle_0;
 883         if (flags & NDR_IN) {
 884                 ZERO_STRUCT(r->out);
 885
 886                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 887                         NDR_PULL_ALLOC(ndr, r->in.handle);
 888                 }
 889                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 890                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 891                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 893                 NDR_PULL_ALLOC(ndr, r->out.handle);
 894                 *r->out.handle = *r->in.handle;
 895         }
 896         if (flags & NDR_OUT) {
 897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 898                         NDR_PULL_ALLOC(ndr, r->out.handle);
 899                 }
 900                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 901                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 902                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 904                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 905         }
 906         return NT_STATUS_OK;
 907 }
 908
 909 _PUBLIC_ void ndr_print_winreg_CloseKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CloseKey *r)
 910 {
 911         ndr_print_struct(ndr, name, "winreg_CloseKey");
 912         ndr->depth++;
 913         if (flags & NDR_SET_VALUES) {
 914                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 915         }
 916         if (flags & NDR_IN) {
 917                 ndr_print_struct(ndr, "in", "winreg_CloseKey");
 918                 ndr->depth++;
 919                 ndr_print_ptr(ndr, "handle", r->in.handle);
 920                 ndr->depth++;
 921                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 922                 ndr->depth--;
 923                 ndr->depth--;
 924         }
 925         if (flags & NDR_OUT) {
 926                 ndr_print_struct(ndr, "out", "winreg_CloseKey");
 927                 ndr->depth++;
 928                 ndr_print_ptr(ndr, "handle", r->out.handle);
 929                 ndr->depth++;
 930                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 931                 ndr->depth--;
 932                 ndr_print_WERROR(ndr, "result", r->out.result);
 933                 ndr->depth--;
 934         }
 935         ndr->depth--;
 936 }
 937
 938 NTSTATUS ndr_push_winreg_CreateKey(struct ndr_push *ndr, int flags, const struct winreg_CreateKey *r)
 939 {
 940         if (flags & NDR_IN) {
 941                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 943                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
 944                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));
 945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
 946                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));
 948                 if (r->in.secdesc) {
 949                         NDR_CHECK(ndr_push_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
 950                 }
 951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.action_taken));
 952                 if (r->in.action_taken) {
 953                         NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->in.action_taken));
 954                 }
 955         }
 956         if (flags & NDR_OUT) {
 957                 if (r->out.new_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 958                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_handle));
 959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.action_taken));
 960                 if (r->out.action_taken) {
 961                         NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->out.action_taken));
 962                 }
 963                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 964         }
 965         return NT_STATUS_OK;
 966 }
 967
 968 NTSTATUS ndr_pull_winreg_CreateKey(struct ndr_pull *ndr, int flags, struct winreg_CreateKey *r)
 969 {
 970         uint32_t _ptr_secdesc;
 971         uint32_t _ptr_action_taken;
 972         TALLOC_CTX *_mem_save_handle_0;
 973         TALLOC_CTX *_mem_save_secdesc_0;
 974         TALLOC_CTX *_mem_save_new_handle_0;
 975         TALLOC_CTX *_mem_save_action_taken_0;
 976         if (flags & NDR_IN) {
 977                 ZERO_STRUCT(r->out);
 978
 979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 980                         NDR_PULL_ALLOC(ndr, r->in.handle);
 981                 }
 982                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 984                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 986                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
 987                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));
 988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
 989                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 990                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
 991                 if (_ptr_secdesc) {
 992                         NDR_PULL_ALLOC(ndr, r->in.secdesc);
 993                 } else {
 994                         r->in.secdesc = NULL;
 995                 }
 996                 if (r->in.secdesc) {
 997                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
 998                         NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);
 999                         NDR_CHECK(ndr_pull_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
1000                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1001                 }
1002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));
1003                 if (_ptr_action_taken) {
1004                         NDR_PULL_ALLOC(ndr, r->in.action_taken);
1005                 } else {
1006                         r->in.action_taken = NULL;
1007                 }
1008                 if (r->in.action_taken) {
1009                         _mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);
1010                         NDR_PULL_SET_MEM_CTX(ndr, r->in.action_taken, 0);
1011                         NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->in.action_taken));
1012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);
1013                 }
1014                 NDR_PULL_ALLOC(ndr, r->out.new_handle);
1015                 ZERO_STRUCTP(r->out.new_handle);
1016         }
1017         if (flags & NDR_OUT) {
1018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1019                         NDR_PULL_ALLOC(ndr, r->out.new_handle);
1020                 }
1021                 _mem_save_new_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.new_handle, LIBNDR_FLAG_REF_ALLOC);
1023                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_handle));
1024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_handle_0, LIBNDR_FLAG_REF_ALLOC);
1025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));
1026                 if (_ptr_action_taken) {
1027                         NDR_PULL_ALLOC(ndr, r->out.action_taken);
1028                 } else {
1029                         r->out.action_taken = NULL;
1030                 }
1031                 if (r->out.action_taken) {
1032                         _mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);
1033                         NDR_PULL_SET_MEM_CTX(ndr, r->out.action_taken, 0);
1034                         NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->out.action_taken));
1035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);
1036                 }
1037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1038         }
1039         return NT_STATUS_OK;
1040 }
1041
1042 _PUBLIC_ void ndr_print_winreg_CreateKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CreateKey *r)
1043 {
1044         ndr_print_struct(ndr, name, "winreg_CreateKey");
1045         ndr->depth++;
1046         if (flags & NDR_SET_VALUES) {
1047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1048         }
1049         if (flags & NDR_IN) {
1050                 ndr_print_struct(ndr, "in", "winreg_CreateKey");
1051                 ndr->depth++;
1052                 ndr_print_ptr(ndr, "handle", r->in.handle);
1053                 ndr->depth++;
1054                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1055                 ndr->depth--;
1056                 ndr_print_winreg_String(ndr, "name", &r->in.name);
1057                 ndr_print_winreg_String(ndr, "keyclass", &r->in.keyclass);
1058                 ndr_print_uint32(ndr, "options", r->in.options);
1059                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
1060                 ndr_print_ptr(ndr, "secdesc", r->in.secdesc);
1061                 ndr->depth++;
1062                 if (r->in.secdesc) {
1063                         ndr_print_winreg_SecBuf(ndr, "secdesc", r->in.secdesc);
1064                 }
1065                 ndr->depth--;
1066                 ndr_print_ptr(ndr, "action_taken", r->in.action_taken);
1067                 ndr->depth++;
1068                 if (r->in.action_taken) {
1069                         ndr_print_winreg_CreateAction(ndr, "action_taken", *r->in.action_taken);
1070                 }
1071                 ndr->depth--;
1072                 ndr->depth--;
1073         }
1074         if (flags & NDR_OUT) {
1075                 ndr_print_struct(ndr, "out", "winreg_CreateKey");
1076                 ndr->depth++;
1077                 ndr_print_ptr(ndr, "new_handle", r->out.new_handle);
1078                 ndr->depth++;
1079                 ndr_print_policy_handle(ndr, "new_handle", r->out.new_handle);
1080                 ndr->depth--;
1081                 ndr_print_ptr(ndr, "action_taken", r->out.action_taken);
1082                 ndr->depth++;
1083                 if (r->out.action_taken) {
1084                         ndr_print_winreg_CreateAction(ndr, "action_taken", *r->out.action_taken);
1085                 }
1086                 ndr->depth--;
1087                 ndr_print_WERROR(ndr, "result", r->out.result);
1088                 ndr->depth--;
1089         }
1090         ndr->depth--;
1091 }
1092
1093 NTSTATUS ndr_push_winreg_DeleteKey(struct ndr_push *ndr, int flags, const struct winreg_DeleteKey *r)
1094 {
1095         if (flags & NDR_IN) {
1096                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1097                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1098                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
1099         }
1100         if (flags & NDR_OUT) {
1101                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1102         }
1103         return NT_STATUS_OK;
1104 }
1105
1106 NTSTATUS ndr_pull_winreg_DeleteKey(struct ndr_pull *ndr, int flags, struct winreg_DeleteKey *r)
1107 {
1108         TALLOC_CTX *_mem_save_handle_0;
1109         if (flags & NDR_IN) {
1110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1111                         NDR_PULL_ALLOC(ndr, r->in.handle);
1112                 }
1113                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1114                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1115                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1117                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
1118         }
1119         if (flags & NDR_OUT) {
1120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1121         }
1122         return NT_STATUS_OK;
1123 }
1124
1125 _PUBLIC_ void ndr_print_winreg_DeleteKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteKey *r)
1126 {
1127         ndr_print_struct(ndr, name, "winreg_DeleteKey");
1128         ndr->depth++;
1129         if (flags & NDR_SET_VALUES) {
1130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1131         }
1132         if (flags & NDR_IN) {
1133                 ndr_print_struct(ndr, "in", "winreg_DeleteKey");
1134                 ndr->depth++;
1135                 ndr_print_ptr(ndr, "handle", r->in.handle);
1136                 ndr->depth++;
1137                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1138                 ndr->depth--;
1139                 ndr_print_winreg_String(ndr, "key", &r->in.key);
1140                 ndr->depth--;
1141         }
1142         if (flags & NDR_OUT) {
1143                 ndr_print_struct(ndr, "out", "winreg_DeleteKey");
1144                 ndr->depth++;
1145                 ndr_print_WERROR(ndr, "result", r->out.result);
1146                 ndr->depth--;
1147         }
1148         ndr->depth--;
1149 }
1150
1151 NTSTATUS ndr_push_winreg_DeleteValue(struct ndr_push *ndr, int flags, const struct winreg_DeleteValue *r)
1152 {
1153         if (flags & NDR_IN) {
1154                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1155                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1156                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));
1157         }
1158         if (flags & NDR_OUT) {
1159                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1160         }
1161         return NT_STATUS_OK;
1162 }
1163
1164 NTSTATUS ndr_pull_winreg_DeleteValue(struct ndr_pull *ndr, int flags, struct winreg_DeleteValue *r)
1165 {
1166         TALLOC_CTX *_mem_save_handle_0;
1167         if (flags & NDR_IN) {
1168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1169                         NDR_PULL_ALLOC(ndr, r->in.handle);
1170                 }
1171                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1172                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1173                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1175                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));
1176         }
1177         if (flags & NDR_OUT) {
1178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1179         }
1180         return NT_STATUS_OK;
1181 }
1182
1183 _PUBLIC_ void ndr_print_winreg_DeleteValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteValue *r)
1184 {
1185         ndr_print_struct(ndr, name, "winreg_DeleteValue");
1186         ndr->depth++;
1187         if (flags & NDR_SET_VALUES) {
1188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1189         }
1190         if (flags & NDR_IN) {
1191                 ndr_print_struct(ndr, "in", "winreg_DeleteValue");
1192                 ndr->depth++;
1193                 ndr_print_ptr(ndr, "handle", r->in.handle);
1194                 ndr->depth++;
1195                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1196                 ndr->depth--;
1197                 ndr_print_winreg_String(ndr, "value", &r->in.value);
1198                 ndr->depth--;
1199         }
1200         if (flags & NDR_OUT) {
1201                 ndr_print_struct(ndr, "out", "winreg_DeleteValue");
1202                 ndr->depth++;
1203                 ndr_print_WERROR(ndr, "result", r->out.result);
1204                 ndr->depth--;
1205         }
1206         ndr->depth--;
1207 }
1208
1209 NTSTATUS ndr_push_winreg_EnumKey(struct ndr_push *ndr, int flags, const struct winreg_EnumKey *r)
1210 {
1211         if (flags & NDR_IN) {
1212                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1213                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
1215                 if (r->in.name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1216                 NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1217                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyclass));
1218                 if (r->in.keyclass) {
1219                         NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));
1220                 }
1221                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.last_changed_time));
1222                 if (r->in.last_changed_time) {
1223                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->in.last_changed_time));
1224                 }
1225         }
1226         if (flags & NDR_OUT) {
1227                 if (r->out.name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1228                 NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.keyclass));
1230                 if (r->out.keyclass) {
1231                         NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));
1232                 }
1233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.last_changed_time));
1234                 if (r->out.last_changed_time) {
1235                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
1236                 }
1237                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1238         }
1239         return NT_STATUS_OK;
1240 }
1241
1242 NTSTATUS ndr_pull_winreg_EnumKey(struct ndr_pull *ndr, int flags, struct winreg_EnumKey *r)
1243 {
1244         uint32_t _ptr_keyclass;
1245         uint32_t _ptr_last_changed_time;
1246         TALLOC_CTX *_mem_save_handle_0;
1247         TALLOC_CTX *_mem_save_name_0;
1248         TALLOC_CTX *_mem_save_keyclass_0;
1249         TALLOC_CTX *_mem_save_last_changed_time_0;
1250         if (flags & NDR_IN) {
1251                 ZERO_STRUCT(r->out);
1252
1253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1254                         NDR_PULL_ALLOC(ndr, r->in.handle);
1255                 }
1256                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1257                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1258                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
1261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1262                         NDR_PULL_ALLOC(ndr, r->in.name);
1263                 }
1264                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1265                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
1266                 NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));
1269                 if (_ptr_keyclass) {
1270                         NDR_PULL_ALLOC(ndr, r->in.keyclass);
1271                 } else {
1272                         r->in.keyclass = NULL;
1273                 }
1274                 if (r->in.keyclass) {
1275                         _mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);
1276                         NDR_PULL_SET_MEM_CTX(ndr, r->in.keyclass, 0);
1277                         NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));
1278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);
1279                 }
1280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
1281                 if (_ptr_last_changed_time) {
1282                         NDR_PULL_ALLOC(ndr, r->in.last_changed_time);
1283                 } else {
1284                         r->in.last_changed_time = NULL;
1285                 }
1286                 if (r->in.last_changed_time) {
1287                         _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1288                         NDR_PULL_SET_MEM_CTX(ndr, r->in.last_changed_time, 0);
1289                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->in.last_changed_time));
1290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
1291                 }
1292                 NDR_PULL_ALLOC(ndr, r->out.name);
1293                 *r->out.name = *r->in.name;
1294         }
1295         if (flags & NDR_OUT) {
1296                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1297                         NDR_PULL_ALLOC(ndr, r->out.name);
1298                 }
1299                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1300                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
1301                 NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));
1304                 if (_ptr_keyclass) {
1305                         NDR_PULL_ALLOC(ndr, r->out.keyclass);
1306                 } else {
1307                         r->out.keyclass = NULL;
1308                 }
1309                 if (r->out.keyclass) {
1310                         _mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);
1311                         NDR_PULL_SET_MEM_CTX(ndr, r->out.keyclass, 0);
1312                         NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));
1313                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);
1314                 }
1315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
1316                 if (_ptr_last_changed_time) {
1317                         NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
1318                 } else {
1319                         r->out.last_changed_time = NULL;
1320                 }
1321                 if (r->out.last_changed_time) {
1322                         _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1323                         NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, 0);
1324                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
1325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
1326                 }
1327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1328         }
1329         return NT_STATUS_OK;
1330 }
1331
1332 _PUBLIC_ void ndr_print_winreg_EnumKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumKey *r)
1333 {
1334         ndr_print_struct(ndr, name, "winreg_EnumKey");
1335         ndr->depth++;
1336         if (flags & NDR_SET_VALUES) {
1337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1338         }
1339         if (flags & NDR_IN) {
1340                 ndr_print_struct(ndr, "in", "winreg_EnumKey");
1341                 ndr->depth++;
1342                 ndr_print_ptr(ndr, "handle", r->in.handle);
1343                 ndr->depth++;
1344                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1345                 ndr->depth--;
1346                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
1347                 ndr_print_ptr(ndr, "name", r->in.name);
1348                 ndr->depth++;
1349                 ndr_print_winreg_StringBuf(ndr, "name", r->in.name);
1350                 ndr->depth--;
1351                 ndr_print_ptr(ndr, "keyclass", r->in.keyclass);
1352                 ndr->depth++;
1353                 if (r->in.keyclass) {
1354                         ndr_print_winreg_StringBuf(ndr, "keyclass", r->in.keyclass);
1355                 }
1356                 ndr->depth--;
1357                 ndr_print_ptr(ndr, "last_changed_time", r->in.last_changed_time);
1358                 ndr->depth++;
1359                 if (r->in.last_changed_time) {
1360                         ndr_print_NTTIME(ndr, "last_changed_time", *r->in.last_changed_time);
1361                 }
1362                 ndr->depth--;
1363                 ndr->depth--;
1364         }
1365         if (flags & NDR_OUT) {
1366                 ndr_print_struct(ndr, "out", "winreg_EnumKey");
1367                 ndr->depth++;
1368                 ndr_print_ptr(ndr, "name", r->out.name);
1369                 ndr->depth++;
1370                 ndr_print_winreg_StringBuf(ndr, "name", r->out.name);
1371                 ndr->depth--;
1372                 ndr_print_ptr(ndr, "keyclass", r->out.keyclass);
1373                 ndr->depth++;
1374                 if (r->out.keyclass) {
1375                         ndr_print_winreg_StringBuf(ndr, "keyclass", r->out.keyclass);
1376                 }
1377                 ndr->depth--;
1378                 ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
1379                 ndr->depth++;
1380                 if (r->out.last_changed_time) {
1381                         ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
1382                 }
1383                 ndr->depth--;
1384                 ndr_print_WERROR(ndr, "result", r->out.result);
1385                 ndr->depth--;
1386         }
1387         ndr->depth--;
1388 }
1389
1390 NTSTATUS ndr_push_winreg_EnumValue(struct ndr_push *ndr, int flags, const struct winreg_EnumValue *r)
1391 {
1392         if (flags & NDR_IN) {
1393                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1394                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
1396                 if (r->in.name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1397                 NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));
1399                 if (r->in.type) {
1400                         NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));
1401                 }
1402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
1403                 if (r->in.data) {
1404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));
1405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.value_length));
1407                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, *r->in.value_length));
1408                 }
1409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_size));
1410                 if (r->in.data_size) {
1411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));
1412                 }
1413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.value_length));
1414                 if (r->in.value_length) {
1415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.value_length));
1416                 }
1417         }
1418         if (flags & NDR_OUT) {
1419                 if (r->out.name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1420                 NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));
1422                 if (r->out.type) {
1423                         NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
1424                 }
1425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data));
1426                 if (r->out.data) {
1427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));
1428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_length));
1430                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, *r->out.value_length));
1431                 }
1432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_size));
1433                 if (r->out.data_size) {
1434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));
1435                 }
1436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.value_length));
1437                 if (r->out.value_length) {
1438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_length));
1439                 }
1440                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1441         }
1442         return NT_STATUS_OK;
1443 }
1444
1445 NTSTATUS ndr_pull_winreg_EnumValue(struct ndr_pull *ndr, int flags, struct winreg_EnumValue *r)
1446 {
1447         uint32_t _ptr_type;
1448         uint32_t _ptr_data;
1449         uint32_t _ptr_data_size;
1450         uint32_t _ptr_value_length;
1451         TALLOC_CTX *_mem_save_handle_0;
1452         TALLOC_CTX *_mem_save_name_0;
1453         TALLOC_CTX *_mem_save_type_0;
1454         TALLOC_CTX *_mem_save_data_0;
1455         TALLOC_CTX *_mem_save_data_size_0;
1456         TALLOC_CTX *_mem_save_value_length_0;
1457         if (flags & NDR_IN) {
1458                 ZERO_STRUCT(r->out);
1459
1460                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1461                         NDR_PULL_ALLOC(ndr, r->in.handle);
1462                 }
1463                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1464                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1465                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
1468                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1469                         NDR_PULL_ALLOC(ndr, r->in.name);
1470                 }
1471                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1472                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
1473                 NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1474                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
1476                 if (_ptr_type) {
1477                         NDR_PULL_ALLOC(ndr, r->in.type);
1478                 } else {
1479                         r->in.type = NULL;
1480                 }
1481                 if (r->in.type) {
1482                         _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
1483                         NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);
1484                         NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));
1485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
1486                 }
1487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1488                 if (_ptr_data) {
1489                         NDR_PULL_ALLOC(ndr, r->in.data);
1490                 } else {
1491                         r->in.data = NULL;
1492                 }
1493                 if (r->in.data) {
1494                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1495                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
1496                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
1497                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data));
1498                         if (ndr_get_array_length(ndr, &r->in.data) > ndr_get_array_size(ndr, &r->in.data)) {
1499                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.data), ndr_get_array_length(ndr, &r->in.data));
1500                         }
1501                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
1502                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_length(ndr, &r->in.data)));
1503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
1504                 }
1505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
1506                 if (_ptr_data_size) {
1507                         NDR_PULL_ALLOC(ndr, r->in.data_size);
1508                 } else {
1509                         r->in.data_size = NULL;
1510                 }
1511                 if (r->in.data_size) {
1512                         _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1513                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_size, 0);
1514                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_size));
1515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
1516                 }
1517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_length));
1518                 if (_ptr_value_length) {
1519                         NDR_PULL_ALLOC(ndr, r->in.value_length);
1520                 } else {
1521                         r->in.value_length = NULL;
1522                 }
1523                 if (r->in.value_length) {
1524                         _mem_save_value_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                         NDR_PULL_SET_MEM_CTX(ndr, r->in.value_length, 0);
1526                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.value_length));
1527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_length_0, 0);
1528                 }
1529                 NDR_PULL_ALLOC(ndr, r->out.name);
1530                 *r->out.name = *r->in.name;
1531                 if (r->in.data) {
1532                         if (r->in.data_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1533                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, *r->in.data_size));
1534                 }
1535                 if (r->in.data) {
1536                         if (r->in.value_length == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1537                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.data, *r->in.value_length));
1538                 }
1539         }
1540         if (flags & NDR_OUT) {
1541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1542                         NDR_PULL_ALLOC(ndr, r->out.name);
1543                 }
1544                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
1546                 NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
1549                 if (_ptr_type) {
1550                         NDR_PULL_ALLOC(ndr, r->out.type);
1551                 } else {
1552                         r->out.type = NULL;
1553                 }
1554                 if (r->out.type) {
1555                         _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
1556                         NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);
1557                         NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
1558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
1559                 }
1560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1561                 if (_ptr_data) {
1562                         NDR_PULL_ALLOC(ndr, r->out.data);
1563                 } else {
1564                         r->out.data = NULL;
1565                 }
1566                 if (r->out.data) {
1567                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1568                         NDR_PULL_SET_MEM_CTX(ndr, r->out.data, 0);
1569                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
1570                         NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data));
1571                         if (ndr_get_array_length(ndr, &r->out.data) > ndr_get_array_size(ndr, &r->out.data)) {
1572                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.data), ndr_get_array_length(ndr, &r->out.data));
1573                         }
1574                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
1575                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_length(ndr, &r->out.data)));
1576                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
1577                 }
1578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
1579                 if (_ptr_data_size) {
1580                         NDR_PULL_ALLOC(ndr, r->out.data_size);
1581                 } else {
1582                         r->out.data_size = NULL;
1583                 }
1584                 if (r->out.data_size) {
1585                         _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1586                         NDR_PULL_SET_MEM_CTX(ndr, r->out.data_size, 0);
1587                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_size));
1588                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
1589                 }
1590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_length));
1591                 if (_ptr_value_length) {
1592                         NDR_PULL_ALLOC(ndr, r->out.value_length);
1593                 } else {
1594                         r->out.value_length = NULL;
1595                 }
1596                 if (r->out.value_length) {
1597                         _mem_save_value_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
1598                         NDR_PULL_SET_MEM_CTX(ndr, r->out.value_length, 0);
1599                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_length));
1600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_length_0, 0);
1601                 }
1602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1603                 if (r->out.data) {
1604                         if (r->out.data_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1605                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, *r->out.data_size));
1606                 }
1607                 if (r->out.data) {
1608                         if (r->out.value_length == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1609                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.data, *r->out.value_length));
1610                 }
1611         }
1612         return NT_STATUS_OK;
1613 }
1614
1615 _PUBLIC_ void ndr_print_winreg_EnumValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumValue *r)
1616 {
1617         ndr_print_struct(ndr, name, "winreg_EnumValue");
1618         ndr->depth++;
1619         if (flags & NDR_SET_VALUES) {
1620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1621         }
1622         if (flags & NDR_IN) {
1623                 ndr_print_struct(ndr, "in", "winreg_EnumValue");
1624                 ndr->depth++;
1625                 ndr_print_ptr(ndr, "handle", r->in.handle);
1626                 ndr->depth++;
1627                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1628                 ndr->depth--;
1629                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
1630                 ndr_print_ptr(ndr, "name", r->in.name);
1631                 ndr->depth++;
1632                 ndr_print_winreg_StringBuf(ndr, "name", r->in.name);
1633                 ndr->depth--;
1634                 ndr_print_ptr(ndr, "type", r->in.type);
1635                 ndr->depth++;
1636                 if (r->in.type) {
1637                         ndr_print_winreg_Type(ndr, "type", *r->in.type);
1638                 }
1639                 ndr->depth--;
1640                 ndr_print_ptr(ndr, "data", r->in.data);
1641                 ndr->depth++;
1642                 if (r->in.data) {
1643                         ndr_print_array_uint8(ndr, "data", r->in.data, *r->in.value_length);
1644                 }
1645                 ndr->depth--;
1646                 ndr_print_ptr(ndr, "data_size", r->in.data_size);
1647                 ndr->depth++;
1648                 if (r->in.data_size) {
1649                         ndr_print_uint32(ndr, "data_size", *r->in.data_size);
1650                 }
1651                 ndr->depth--;
1652                 ndr_print_ptr(ndr, "value_length", r->in.value_length);
1653                 ndr->depth++;
1654                 if (r->in.value_length) {
1655                         ndr_print_uint32(ndr, "value_length", *r->in.value_length);
1656                 }
1657                 ndr->depth--;
1658                 ndr->depth--;
1659         }
1660         if (flags & NDR_OUT) {
1661                 ndr_print_struct(ndr, "out", "winreg_EnumValue");
1662                 ndr->depth++;
1663                 ndr_print_ptr(ndr, "name", r->out.name);
1664                 ndr->depth++;
1665                 ndr_print_winreg_StringBuf(ndr, "name", r->out.name);
1666                 ndr->depth--;
1667                 ndr_print_ptr(ndr, "type", r->out.type);
1668                 ndr->depth++;
1669                 if (r->out.type) {
1670                         ndr_print_winreg_Type(ndr, "type", *r->out.type);
1671                 }
1672                 ndr->depth--;
1673                 ndr_print_ptr(ndr, "data", r->out.data);
1674                 ndr->depth++;
1675                 if (r->out.data) {
1676                         ndr_print_array_uint8(ndr, "data", r->out.data, *r->out.value_length);
1677                 }
1678                 ndr->depth--;
1679                 ndr_print_ptr(ndr, "data_size", r->out.data_size);
1680                 ndr->depth++;
1681                 if (r->out.data_size) {
1682                         ndr_print_uint32(ndr, "data_size", *r->out.data_size);
1683                 }
1684                 ndr->depth--;
1685                 ndr_print_ptr(ndr, "value_length", r->out.value_length);
1686                 ndr->depth++;
1687                 if (r->out.value_length) {
1688                         ndr_print_uint32(ndr, "value_length", *r->out.value_length);
1689                 }
1690                 ndr->depth--;
1691                 ndr_print_WERROR(ndr, "result", r->out.result);
1692                 ndr->depth--;
1693         }
1694         ndr->depth--;
1695 }
1696
1697 NTSTATUS ndr_push_winreg_FlushKey(struct ndr_push *ndr, int flags, const struct winreg_FlushKey *r)
1698 {
1699         if (flags & NDR_IN) {
1700                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1701                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1702         }
1703         if (flags & NDR_OUT) {
1704                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1705         }
1706         return NT_STATUS_OK;
1707 }
1708
1709 NTSTATUS ndr_pull_winreg_FlushKey(struct ndr_pull *ndr, int flags, struct winreg_FlushKey *r)
1710 {
1711         TALLOC_CTX *_mem_save_handle_0;
1712         if (flags & NDR_IN) {
1713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1714                         NDR_PULL_ALLOC(ndr, r->in.handle);
1715                 }
1716                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1717                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1718                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1720         }
1721         if (flags & NDR_OUT) {
1722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1723         }
1724         return NT_STATUS_OK;
1725 }
1726
1727 _PUBLIC_ void ndr_print_winreg_FlushKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_FlushKey *r)
1728 {
1729         ndr_print_struct(ndr, name, "winreg_FlushKey");
1730         ndr->depth++;
1731         if (flags & NDR_SET_VALUES) {
1732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1733         }
1734         if (flags & NDR_IN) {
1735                 ndr_print_struct(ndr, "in", "winreg_FlushKey");
1736                 ndr->depth++;
1737                 ndr_print_ptr(ndr, "handle", r->in.handle);
1738                 ndr->depth++;
1739                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1740                 ndr->depth--;
1741                 ndr->depth--;
1742         }
1743         if (flags & NDR_OUT) {
1744                 ndr_print_struct(ndr, "out", "winreg_FlushKey");
1745                 ndr->depth++;
1746                 ndr_print_WERROR(ndr, "result", r->out.result);
1747                 ndr->depth--;
1748         }
1749         ndr->depth--;
1750 }
1751
1752 NTSTATUS ndr_push_winreg_GetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_GetKeySecurity *r)
1753 {
1754         if (flags & NDR_IN) {
1755                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1756                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1757                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
1758                 if (r->in.sd == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1759                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
1760         }
1761         if (flags & NDR_OUT) {
1762                 if (r->out.sd == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1763                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
1764                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1765         }
1766         return NT_STATUS_OK;
1767 }
1768
1769 NTSTATUS ndr_pull_winreg_GetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_GetKeySecurity *r)
1770 {
1771         TALLOC_CTX *_mem_save_handle_0;
1772         TALLOC_CTX *_mem_save_sd_0;
1773         if (flags & NDR_IN) {
1774                 ZERO_STRUCT(r->out);
1775
1776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1777                         NDR_PULL_ALLOC(ndr, r->in.handle);
1778                 }
1779                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1781                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1783                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
1784                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1785                         NDR_PULL_ALLOC(ndr, r->in.sd);
1786                 }
1787                 _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
1788                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);
1789                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
1790                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
1791                 NDR_PULL_ALLOC(ndr, r->out.sd);
1792                 *r->out.sd = *r->in.sd;
1793         }
1794         if (flags & NDR_OUT) {
1795                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1796                         NDR_PULL_ALLOC(ndr, r->out.sd);
1797                 }
1798                 _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
1799                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sd, LIBNDR_FLAG_REF_ALLOC);
1800                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
1801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
1802                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1803         }
1804         return NT_STATUS_OK;
1805 }
1806
1807 _PUBLIC_ void ndr_print_winreg_GetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetKeySecurity *r)
1808 {
1809         ndr_print_struct(ndr, name, "winreg_GetKeySecurity");
1810         ndr->depth++;
1811         if (flags & NDR_SET_VALUES) {
1812                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1813         }
1814         if (flags & NDR_IN) {
1815                 ndr_print_struct(ndr, "in", "winreg_GetKeySecurity");
1816                 ndr->depth++;
1817                 ndr_print_ptr(ndr, "handle", r->in.handle);
1818                 ndr->depth++;
1819                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1820                 ndr->depth--;
1821                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
1822                 ndr_print_ptr(ndr, "sd", r->in.sd);
1823                 ndr->depth++;
1824                 ndr_print_KeySecurityData(ndr, "sd", r->in.sd);
1825                 ndr->depth--;
1826                 ndr->depth--;
1827         }
1828         if (flags & NDR_OUT) {
1829                 ndr_print_struct(ndr, "out", "winreg_GetKeySecurity");
1830                 ndr->depth++;
1831                 ndr_print_ptr(ndr, "sd", r->out.sd);
1832                 ndr->depth++;
1833                 ndr_print_KeySecurityData(ndr, "sd", r->out.sd);
1834                 ndr->depth--;
1835                 ndr_print_WERROR(ndr, "result", r->out.result);
1836                 ndr->depth--;
1837         }
1838         ndr->depth--;
1839 }
1840
1841 NTSTATUS ndr_push_winreg_LoadKey(struct ndr_push *ndr, int flags, const struct winreg_LoadKey *r)
1842 {
1843         if (flags & NDR_IN) {
1844                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1845                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyname));
1847                 if (r->in.keyname) {
1848                         NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));
1849                 }
1850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.filename));
1851                 if (r->in.filename) {
1852                         NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
1853                 }
1854         }
1855         if (flags & NDR_OUT) {
1856                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1857         }
1858         return NT_STATUS_OK;
1859 }
1860
1861 NTSTATUS ndr_pull_winreg_LoadKey(struct ndr_pull *ndr, int flags, struct winreg_LoadKey *r)
1862 {
1863         uint32_t _ptr_keyname;
1864         uint32_t _ptr_filename;
1865         TALLOC_CTX *_mem_save_handle_0;
1866         TALLOC_CTX *_mem_save_keyname_0;
1867         TALLOC_CTX *_mem_save_filename_0;
1868         if (flags & NDR_IN) {
1869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1870                         NDR_PULL_ALLOC(ndr, r->in.handle);
1871                 }
1872                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1873                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1874                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyname));
1877                 if (_ptr_keyname) {
1878                         NDR_PULL_ALLOC(ndr, r->in.keyname);
1879                 } else {
1880                         r->in.keyname = NULL;
1881                 }
1882                 if (r->in.keyname) {
1883                         _mem_save_keyname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1884                         NDR_PULL_SET_MEM_CTX(ndr, r->in.keyname, 0);
1885                         NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));
1886                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyname_0, 0);
1887                 }
1888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filename));
1889                 if (_ptr_filename) {
1890                         NDR_PULL_ALLOC(ndr, r->in.filename);
1891                 } else {
1892                         r->in.filename = NULL;
1893                 }
1894                 if (r->in.filename) {
1895                         _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1896                         NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, 0);
1897                         NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
1898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, 0);
1899                 }
1900         }
1901         if (flags & NDR_OUT) {
1902                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1903         }
1904         return NT_STATUS_OK;
1905 }
1906
1907 _PUBLIC_ void ndr_print_winreg_LoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_LoadKey *r)
1908 {
1909         ndr_print_struct(ndr, name, "winreg_LoadKey");
1910         ndr->depth++;
1911         if (flags & NDR_SET_VALUES) {
1912                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1913         }
1914         if (flags & NDR_IN) {
1915                 ndr_print_struct(ndr, "in", "winreg_LoadKey");
1916                 ndr->depth++;
1917                 ndr_print_ptr(ndr, "handle", r->in.handle);
1918                 ndr->depth++;
1919                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1920                 ndr->depth--;
1921                 ndr_print_ptr(ndr, "keyname", r->in.keyname);
1922                 ndr->depth++;
1923                 if (r->in.keyname) {
1924                         ndr_print_winreg_String(ndr, "keyname", r->in.keyname);
1925                 }
1926                 ndr->depth--;
1927                 ndr_print_ptr(ndr, "filename", r->in.filename);
1928                 ndr->depth++;
1929                 if (r->in.filename) {
1930                         ndr_print_winreg_String(ndr, "filename", r->in.filename);
1931                 }
1932                 ndr->depth--;
1933                 ndr->depth--;
1934         }
1935         if (flags & NDR_OUT) {
1936                 ndr_print_struct(ndr, "out", "winreg_LoadKey");
1937                 ndr->depth++;
1938                 ndr_print_WERROR(ndr, "result", r->out.result);
1939                 ndr->depth--;
1940         }
1941         ndr->depth--;
1942 }
1943
1944 NTSTATUS ndr_push_winreg_NotifyChangeKeyValue(struct ndr_push *ndr, int flags, const struct winreg_NotifyChangeKeyValue *r)
1945 {
1946         if (flags & NDR_IN) {
1947                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1948                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1949                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.watch_subtree));
1950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.notify_filter));
1951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
1952                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));
1953                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));
1954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
1955         }
1956         if (flags & NDR_OUT) {
1957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1958         }
1959         return NT_STATUS_OK;
1960 }
1961
1962 NTSTATUS ndr_pull_winreg_NotifyChangeKeyValue(struct ndr_pull *ndr, int flags, struct winreg_NotifyChangeKeyValue *r)
1963 {
1964         TALLOC_CTX *_mem_save_handle_0;
1965         if (flags & NDR_IN) {
1966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1967                         NDR_PULL_ALLOC(ndr, r->in.handle);
1968                 }
1969                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1971                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1973                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.watch_subtree));
1974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.notify_filter));
1975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
1976                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));
1977                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));
1978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
1979         }
1980         if (flags & NDR_OUT) {
1981                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1982         }
1983         return NT_STATUS_OK;
1984 }
1985
1986 _PUBLIC_ void ndr_print_winreg_NotifyChangeKeyValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_NotifyChangeKeyValue *r)
1987 {
1988         ndr_print_struct(ndr, name, "winreg_NotifyChangeKeyValue");
1989         ndr->depth++;
1990         if (flags & NDR_SET_VALUES) {
1991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1992         }
1993         if (flags & NDR_IN) {
1994                 ndr_print_struct(ndr, "in", "winreg_NotifyChangeKeyValue");
1995                 ndr->depth++;
1996                 ndr_print_ptr(ndr, "handle", r->in.handle);
1997                 ndr->depth++;
1998                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1999                 ndr->depth--;
2000                 ndr_print_uint8(ndr, "watch_subtree", r->in.watch_subtree);
2001                 ndr_print_uint32(ndr, "notify_filter", r->in.notify_filter);
2002                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
2003                 ndr_print_winreg_String(ndr, "string1", &r->in.string1);
2004                 ndr_print_winreg_String(ndr, "string2", &r->in.string2);
2005                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
2006                 ndr->depth--;
2007         }
2008         if (flags & NDR_OUT) {
2009                 ndr_print_struct(ndr, "out", "winreg_NotifyChangeKeyValue");
2010                 ndr->depth++;
2011                 ndr_print_WERROR(ndr, "result", r->out.result);
2012                 ndr->depth--;
2013         }
2014         ndr->depth--;
2015 }
2016
2017 NTSTATUS ndr_push_winreg_OpenKey(struct ndr_push *ndr, int flags, const struct winreg_OpenKey *r)
2018 {
2019         if (flags & NDR_IN) {
2020                 if (r->in.parent_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2021                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.parent_handle));
2022                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));
2023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
2024                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
2025         }
2026         if (flags & NDR_OUT) {
2027                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2028                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
2029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2030         }
2031         return NT_STATUS_OK;
2032 }
2033
2034 NTSTATUS ndr_pull_winreg_OpenKey(struct ndr_pull *ndr, int flags, struct winreg_OpenKey *r)
2035 {
2036         TALLOC_CTX *_mem_save_parent_handle_0;
2037         TALLOC_CTX *_mem_save_handle_0;
2038         if (flags & NDR_IN) {
2039                 ZERO_STRUCT(r->out);
2040
2041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2042                         NDR_PULL_ALLOC(ndr, r->in.parent_handle);
2043                 }
2044                 _mem_save_parent_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2045                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parent_handle, LIBNDR_FLAG_REF_ALLOC);
2046                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.parent_handle));
2047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_handle_0, LIBNDR_FLAG_REF_ALLOC);
2048                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));
2049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
2050                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
2051                 NDR_PULL_ALLOC(ndr, r->out.handle);
2052                 ZERO_STRUCTP(r->out.handle);
2053         }
2054         if (flags & NDR_OUT) {
2055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2056                         NDR_PULL_ALLOC(ndr, r->out.handle);
2057                 }
2058                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
2060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
2061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2063         }
2064         return NT_STATUS_OK;
2065 }
2066
2067 _PUBLIC_ void ndr_print_winreg_OpenKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenKey *r)
2068 {
2069         ndr_print_struct(ndr, name, "winreg_OpenKey");
2070         ndr->depth++;
2071         if (flags & NDR_SET_VALUES) {
2072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2073         }
2074         if (flags & NDR_IN) {
2075                 ndr_print_struct(ndr, "in", "winreg_OpenKey");
2076                 ndr->depth++;
2077                 ndr_print_ptr(ndr, "parent_handle", r->in.parent_handle);
2078                 ndr->depth++;
2079                 ndr_print_policy_handle(ndr, "parent_handle", r->in.parent_handle);
2080                 ndr->depth--;
2081                 ndr_print_winreg_String(ndr, "keyname", &r->in.keyname);
2082                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
2083                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
2084                 ndr->depth--;
2085         }
2086         if (flags & NDR_OUT) {
2087                 ndr_print_struct(ndr, "out", "winreg_OpenKey");
2088                 ndr->depth++;
2089                 ndr_print_ptr(ndr, "handle", r->out.handle);
2090                 ndr->depth++;
2091                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
2092                 ndr->depth--;
2093                 ndr_print_WERROR(ndr, "result", r->out.result);
2094                 ndr->depth--;
2095         }
2096         ndr->depth--;
2097 }
2098
2099 NTSTATUS ndr_push_winreg_QueryInfoKey(struct ndr_push *ndr, int flags, const struct winreg_QueryInfoKey *r)
2100 {
2101         if (flags & NDR_IN) {
2102                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2103                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2104                 if (r->in.classname == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2105                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));
2106         }
2107         if (flags & NDR_OUT) {
2108                 if (r->out.classname == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2109                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));
2110                 if (r->out.num_subkeys == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));
2112                 if (r->out.max_subkeylen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));
2114                 if (r->out.max_subkeysize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeysize));
2116                 if (r->out.num_values == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));
2118                 if (r->out.max_valnamelen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valnamelen));
2120                 if (r->out.max_valbufsize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valbufsize));
2122                 if (r->out.secdescsize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.secdescsize));
2124                 if (r->out.last_changed_time == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2125                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
2126                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2127         }
2128         return NT_STATUS_OK;
2129 }
2130
2131 NTSTATUS ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct winreg_QueryInfoKey *r)
2132 {
2133         TALLOC_CTX *_mem_save_handle_0;
2134         TALLOC_CTX *_mem_save_classname_0;
2135         TALLOC_CTX *_mem_save_num_subkeys_0;
2136         TALLOC_CTX *_mem_save_max_subkeylen_0;
2137         TALLOC_CTX *_mem_save_max_subkeysize_0;
2138         TALLOC_CTX *_mem_save_num_values_0;
2139         TALLOC_CTX *_mem_save_max_valnamelen_0;
2140         TALLOC_CTX *_mem_save_max_valbufsize_0;
2141         TALLOC_CTX *_mem_save_secdescsize_0;
2142         TALLOC_CTX *_mem_save_last_changed_time_0;
2143         if (flags & NDR_IN) {
2144                 ZERO_STRUCT(r->out);
2145
2146                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2147                         NDR_PULL_ALLOC(ndr, r->in.handle);
2148                 }
2149                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2150                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2151                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2152                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2154                         NDR_PULL_ALLOC(ndr, r->in.classname);
2155                 }
2156                 _mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2157                 NDR_PULL_SET_MEM_CTX(ndr, r->in.classname, LIBNDR_FLAG_REF_ALLOC);
2158                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));
2159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);
2160                 NDR_PULL_ALLOC(ndr, r->out.classname);
2161                 *r->out.classname = *r->in.classname;
2162                 NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
2163                 ZERO_STRUCTP(r->out.num_subkeys);
2164                 NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
2165                 ZERO_STRUCTP(r->out.max_subkeylen);
2166                 NDR_PULL_ALLOC(ndr, r->out.max_subkeysize);
2167                 ZERO_STRUCTP(r->out.max_subkeysize);
2168                 NDR_PULL_ALLOC(ndr, r->out.num_values);
2169                 ZERO_STRUCTP(r->out.num_values);
2170                 NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
2171                 ZERO_STRUCTP(r->out.max_valnamelen);
2172                 NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
2173                 ZERO_STRUCTP(r->out.max_valbufsize);
2174                 NDR_PULL_ALLOC(ndr, r->out.secdescsize);
2175                 ZERO_STRUCTP(r->out.secdescsize);
2176                 NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
2177                 ZERO_STRUCTP(r->out.last_changed_time);
2178         }
2179         if (flags & NDR_OUT) {
2180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2181                         NDR_PULL_ALLOC(ndr, r->out.classname);
2182                 }
2183                 _mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.classname, LIBNDR_FLAG_REF_ALLOC);
2185                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));
2186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);
2187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2188                         NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
2189                 }
2190                 _mem_save_num_subkeys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2191                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_subkeys, LIBNDR_FLAG_REF_ALLOC);
2192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_subkeys));
2193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_subkeys_0, LIBNDR_FLAG_REF_ALLOC);
2194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2195                         NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
2196                 }
2197                 _mem_save_max_subkeylen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2198                 NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeylen, LIBNDR_FLAG_REF_ALLOC);
2199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));
2200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, LIBNDR_FLAG_REF_ALLOC);
2201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2202                         NDR_PULL_ALLOC(ndr, r->out.max_subkeysize);
2203                 }
2204                 _mem_save_max_subkeysize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2205                 NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeysize, LIBNDR_FLAG_REF_ALLOC);
2206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeysize));
2207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeysize_0, LIBNDR_FLAG_REF_ALLOC);
2208                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2209                         NDR_PULL_ALLOC(ndr, r->out.num_values);
2210                 }
2211                 _mem_save_num_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2212                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_values, LIBNDR_FLAG_REF_ALLOC);
2213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_values));
2214                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_values_0, LIBNDR_FLAG_REF_ALLOC);
2215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2216                         NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
2217                 }
2218                 _mem_save_max_valnamelen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2219                 NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valnamelen, LIBNDR_FLAG_REF_ALLOC);
2220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valnamelen));
2221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valnamelen_0, LIBNDR_FLAG_REF_ALLOC);
2222                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2223                         NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
2224                 }
2225                 _mem_save_max_valbufsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2226                 NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valbufsize, LIBNDR_FLAG_REF_ALLOC);
2227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valbufsize));
2228                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valbufsize_0, LIBNDR_FLAG_REF_ALLOC);
2229                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2230                         NDR_PULL_ALLOC(ndr, r->out.secdescsize);
2231                 }
2232                 _mem_save_secdescsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2233                 NDR_PULL_SET_MEM_CTX(ndr, r->out.secdescsize, LIBNDR_FLAG_REF_ALLOC);
2234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.secdescsize));
2235                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdescsize_0, LIBNDR_FLAG_REF_ALLOC);
2236                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2237                         NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
2238                 }
2239                 _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
2240                 NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, LIBNDR_FLAG_REF_ALLOC);
2241                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
2242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, LIBNDR_FLAG_REF_ALLOC);
2243                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2244         }
2245         return NT_STATUS_OK;
2246 }
2247
2248 _PUBLIC_ void ndr_print_winreg_QueryInfoKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryInfoKey *r)
2249 {
2250         ndr_print_struct(ndr, name, "winreg_QueryInfoKey");
2251         ndr->depth++;
2252         if (flags & NDR_SET_VALUES) {
2253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2254         }
2255         if (flags & NDR_IN) {
2256                 ndr_print_struct(ndr, "in", "winreg_QueryInfoKey");
2257                 ndr->depth++;
2258                 ndr_print_ptr(ndr, "handle", r->in.handle);
2259                 ndr->depth++;
2260                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2261                 ndr->depth--;
2262                 ndr_print_ptr(ndr, "classname", r->in.classname);
2263                 ndr->depth++;
2264                 ndr_print_winreg_String(ndr, "classname", r->in.classname);
2265                 ndr->depth--;
2266                 ndr->depth--;
2267         }
2268         if (flags & NDR_OUT) {
2269                 ndr_print_struct(ndr, "out", "winreg_QueryInfoKey");
2270                 ndr->depth++;
2271                 ndr_print_ptr(ndr, "classname", r->out.classname);
2272                 ndr->depth++;
2273                 ndr_print_winreg_String(ndr, "classname", r->out.classname);
2274                 ndr->depth--;
2275                 ndr_print_ptr(ndr, "num_subkeys", r->out.num_subkeys);
2276                 ndr->depth++;
2277                 ndr_print_uint32(ndr, "num_subkeys", *r->out.num_subkeys);
2278                 ndr->depth--;
2279                 ndr_print_ptr(ndr, "max_subkeylen", r->out.max_subkeylen);
2280                 ndr->depth++;
2281                 ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);
2282                 ndr->depth--;
2283                 ndr_print_ptr(ndr, "max_subkeysize", r->out.max_subkeysize);
2284                 ndr->depth++;
2285                 ndr_print_uint32(ndr, "max_subkeysize", *r->out.max_subkeysize);
2286                 ndr->depth--;
2287                 ndr_print_ptr(ndr, "num_values", r->out.num_values);
2288                 ndr->depth++;
2289                 ndr_print_uint32(ndr, "num_values", *r->out.num_values);
2290                 ndr->depth--;
2291                 ndr_print_ptr(ndr, "max_valnamelen", r->out.max_valnamelen);
2292                 ndr->depth++;
2293                 ndr_print_uint32(ndr, "max_valnamelen", *r->out.max_valnamelen);
2294                 ndr->depth--;
2295                 ndr_print_ptr(ndr, "max_valbufsize", r->out.max_valbufsize);
2296                 ndr->depth++;
2297                 ndr_print_uint32(ndr, "max_valbufsize", *r->out.max_valbufsize);
2298                 ndr->depth--;
2299                 ndr_print_ptr(ndr, "secdescsize", r->out.secdescsize);
2300                 ndr->depth++;
2301                 ndr_print_uint32(ndr, "secdescsize", *r->out.secdescsize);
2302                 ndr->depth--;
2303                 ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
2304                 ndr->depth++;
2305                 ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
2306                 ndr->depth--;
2307                 ndr_print_WERROR(ndr, "result", r->out.result);
2308                 ndr->depth--;
2309         }
2310         ndr->depth--;
2311 }
2312
2313 NTSTATUS ndr_push_winreg_QueryValue(struct ndr_push *ndr, int flags, const struct winreg_QueryValue *r)
2314 {
2315         if (flags & NDR_IN) {
2316                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2317                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2318                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value_name));
2319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));
2320                 if (r->in.type) {
2321                         NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));
2322                 }
2323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
2324                 if (r->in.data) {
2325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));
2326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.value_length));
2328                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, *r->in.value_length));
2329                 }
2330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_size));
2331                 if (r->in.data_size) {
2332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));
2333                 }
2334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.value_length));
2335                 if (r->in.value_length) {
2336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.value_length));
2337                 }
2338         }
2339         if (flags & NDR_OUT) {
2340                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));
2341                 if (r->out.type) {
2342                         NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
2343                 }
2344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data));
2345                 if (r->out.data) {
2346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));
2347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_length));
2349                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, *r->out.value_length));
2350                 }
2351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_size));
2352                 if (r->out.data_size) {
2353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));
2354                 }
2355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.value_length));
2356                 if (r->out.value_length) {
2357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_length));
2358                 }
2359                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2360         }
2361         return NT_STATUS_OK;
2362 }
2363
2364 NTSTATUS ndr_pull_winreg_QueryValue(struct ndr_pull *ndr, int flags, struct winreg_QueryValue *r)
2365 {
2366         uint32_t _ptr_type;
2367         uint32_t _ptr_data;
2368         uint32_t _ptr_data_size;
2369         uint32_t _ptr_value_length;
2370         TALLOC_CTX *_mem_save_handle_0;
2371         TALLOC_CTX *_mem_save_type_0;
2372         TALLOC_CTX *_mem_save_data_0;
2373         TALLOC_CTX *_mem_save_data_size_0;
2374         TALLOC_CTX *_mem_save_value_length_0;
2375         if (flags & NDR_IN) {
2376                 ZERO_STRUCT(r->out);
2377
2378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2379                         NDR_PULL_ALLOC(ndr, r->in.handle);
2380                 }
2381                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2383                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2385                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value_name));
2386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
2387                 if (_ptr_type) {
2388                         NDR_PULL_ALLOC(ndr, r->in.type);
2389                 } else {
2390                         r->in.type = NULL;
2391                 }
2392                 if (r->in.type) {
2393                         _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2394                         NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);
2395                         NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));
2396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
2397                 }
2398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2399                 if (_ptr_data) {
2400                         NDR_PULL_ALLOC(ndr, r->in.data);
2401                 } else {
2402                         r->in.data = NULL;
2403                 }
2404                 if (r->in.data) {
2405                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2406                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
2407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
2408                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data));
2409                         if (ndr_get_array_length(ndr, &r->in.data) > ndr_get_array_size(ndr, &r->in.data)) {
2410                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.data), ndr_get_array_length(ndr, &r->in.data));
2411                         }
2412                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
2413                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_length(ndr, &r->in.data)));
2414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2415                 }
2416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
2417                 if (_ptr_data_size) {
2418                         NDR_PULL_ALLOC(ndr, r->in.data_size);
2419                 } else {
2420                         r->in.data_size = NULL;
2421                 }
2422                 if (r->in.data_size) {
2423                         _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2424                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_size, 0);
2425                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_size));
2426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
2427                 }
2428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_length));
2429                 if (_ptr_value_length) {
2430                         NDR_PULL_ALLOC(ndr, r->in.value_length);
2431                 } else {
2432                         r->in.value_length = NULL;
2433                 }
2434                 if (r->in.value_length) {
2435                         _mem_save_value_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2436                         NDR_PULL_SET_MEM_CTX(ndr, r->in.value_length, 0);
2437                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.value_length));
2438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_length_0, 0);
2439                 }
2440                 if (r->in.data) {
2441                         if (r->in.data_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2442                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, *r->in.data_size));
2443                 }
2444                 if (r->in.data) {
2445                         if (r->in.value_length == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2446                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.data, *r->in.value_length));
2447                 }
2448         }
2449         if (flags & NDR_OUT) {
2450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
2451                 if (_ptr_type) {
2452                         NDR_PULL_ALLOC(ndr, r->out.type);
2453                 } else {
2454                         r->out.type = NULL;
2455                 }
2456                 if (r->out.type) {
2457                         _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2458                         NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);
2459                         NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
2460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
2461                 }
2462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2463                 if (_ptr_data) {
2464                         NDR_PULL_ALLOC(ndr, r->out.data);
2465                 } else {
2466                         r->out.data = NULL;
2467                 }
2468                 if (r->out.data) {
2469                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2470                         NDR_PULL_SET_MEM_CTX(ndr, r->out.data, 0);
2471                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
2472                         NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data));
2473                         if (ndr_get_array_length(ndr, &r->out.data) > ndr_get_array_size(ndr, &r->out.data)) {
2474                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.data), ndr_get_array_length(ndr, &r->out.data));
2475                         }
2476                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
2477                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_length(ndr, &r->out.data)));
2478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2479                 }
2480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
2481                 if (_ptr_data_size) {
2482                         NDR_PULL_ALLOC(ndr, r->out.data_size);
2483                 } else {
2484                         r->out.data_size = NULL;
2485                 }
2486                 if (r->out.data_size) {
2487                         _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2488                         NDR_PULL_SET_MEM_CTX(ndr, r->out.data_size, 0);
2489                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_size));
2490                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
2491                 }
2492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_length));
2493                 if (_ptr_value_length) {
2494                         NDR_PULL_ALLOC(ndr, r->out.value_length);
2495                 } else {
2496                         r->out.value_length = NULL;
2497                 }
2498                 if (r->out.value_length) {
2499                         _mem_save_value_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2500                         NDR_PULL_SET_MEM_CTX(ndr, r->out.value_length, 0);
2501                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_length));
2502                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_length_0, 0);
2503                 }
2504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2505                 if (r->out.data) {
2506                         if (r->out.data_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2507                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, *r->out.data_size));
2508                 }
2509                 if (r->out.data) {
2510                         if (r->out.value_length == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2511                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.data, *r->out.value_length));
2512                 }
2513         }
2514         return NT_STATUS_OK;
2515 }
2516
2517 _PUBLIC_ void ndr_print_winreg_QueryValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryValue *r)
2518 {
2519         ndr_print_struct(ndr, name, "winreg_QueryValue");
2520         ndr->depth++;
2521         if (flags & NDR_SET_VALUES) {
2522                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2523         }
2524         if (flags & NDR_IN) {
2525                 ndr_print_struct(ndr, "in", "winreg_QueryValue");
2526                 ndr->depth++;
2527                 ndr_print_ptr(ndr, "handle", r->in.handle);
2528                 ndr->depth++;
2529                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2530                 ndr->depth--;
2531                 ndr_print_winreg_String(ndr, "value_name", &r->in.value_name);
2532                 ndr_print_ptr(ndr, "type", r->in.type);
2533                 ndr->depth++;
2534                 if (r->in.type) {
2535                         ndr_print_winreg_Type(ndr, "type", *r->in.type);
2536                 }
2537                 ndr->depth--;
2538                 ndr_print_ptr(ndr, "data", r->in.data);
2539                 ndr->depth++;
2540                 if (r->in.data) {
2541                         ndr_print_array_uint8(ndr, "data", r->in.data, *r->in.value_length);
2542                 }
2543                 ndr->depth--;
2544                 ndr_print_ptr(ndr, "data_size", r->in.data_size);
2545                 ndr->depth++;
2546                 if (r->in.data_size) {
2547                         ndr_print_uint32(ndr, "data_size", *r->in.data_size);
2548                 }
2549                 ndr->depth--;
2550                 ndr_print_ptr(ndr, "value_length", r->in.value_length);
2551                 ndr->depth++;
2552                 if (r->in.value_length) {
2553                         ndr_print_uint32(ndr, "value_length", *r->in.value_length);
2554                 }
2555                 ndr->depth--;
2556                 ndr->depth--;
2557         }
2558         if (flags & NDR_OUT) {
2559                 ndr_print_struct(ndr, "out", "winreg_QueryValue");
2560                 ndr->depth++;
2561                 ndr_print_ptr(ndr, "type", r->out.type);
2562                 ndr->depth++;
2563                 if (r->out.type) {
2564                         ndr_print_winreg_Type(ndr, "type", *r->out.type);
2565                 }
2566                 ndr->depth--;
2567                 ndr_print_ptr(ndr, "data", r->out.data);
2568                 ndr->depth++;
2569                 if (r->out.data) {
2570                         ndr_print_array_uint8(ndr, "data", r->out.data, *r->out.value_length);
2571                 }
2572                 ndr->depth--;
2573                 ndr_print_ptr(ndr, "data_size", r->out.data_size);
2574                 ndr->depth++;
2575                 if (r->out.data_size) {
2576                         ndr_print_uint32(ndr, "data_size", *r->out.data_size);
2577                 }
2578                 ndr->depth--;
2579                 ndr_print_ptr(ndr, "value_length", r->out.value_length);
2580                 ndr->depth++;
2581                 if (r->out.value_length) {
2582                         ndr_print_uint32(ndr, "value_length", *r->out.value_length);
2583                 }
2584                 ndr->depth--;
2585                 ndr_print_WERROR(ndr, "result", r->out.result);
2586                 ndr->depth--;
2587         }
2588         ndr->depth--;
2589 }
2590
2591 NTSTATUS ndr_push_winreg_ReplaceKey(struct ndr_push *ndr, int flags, const struct winreg_ReplaceKey *r)
2592 {
2593         if (flags & NDR_IN) {
2594         }
2595         if (flags & NDR_OUT) {
2596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2597         }
2598         return NT_STATUS_OK;
2599 }
2600
2601 NTSTATUS ndr_pull_winreg_ReplaceKey(struct ndr_pull *ndr, int flags, struct winreg_ReplaceKey *r)
2602 {
2603         if (flags & NDR_IN) {
2604         }
2605         if (flags & NDR_OUT) {
2606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2607         }
2608         return NT_STATUS_OK;
2609 }
2610
2611 _PUBLIC_ void ndr_print_winreg_ReplaceKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_ReplaceKey *r)
2612 {
2613         ndr_print_struct(ndr, name, "winreg_ReplaceKey");
2614         ndr->depth++;
2615         if (flags & NDR_SET_VALUES) {
2616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2617         }
2618         if (flags & NDR_IN) {
2619                 ndr_print_struct(ndr, "in", "winreg_ReplaceKey");
2620                 ndr->depth++;
2621                 ndr->depth--;
2622         }
2623         if (flags & NDR_OUT) {
2624                 ndr_print_struct(ndr, "out", "winreg_ReplaceKey");
2625                 ndr->depth++;
2626                 ndr_print_WERROR(ndr, "result", r->out.result);
2627                 ndr->depth--;
2628         }
2629         ndr->depth--;
2630 }
2631
2632 NTSTATUS ndr_push_winreg_RestoreKey(struct ndr_push *ndr, int flags, const struct winreg_RestoreKey *r)
2633 {
2634         if (flags & NDR_IN) {
2635                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2636                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2637                 if (r->in.filename == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2638                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
2640         }
2641         if (flags & NDR_OUT) {
2642                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2643         }
2644         return NT_STATUS_OK;
2645 }
2646
2647 NTSTATUS ndr_pull_winreg_RestoreKey(struct ndr_pull *ndr, int flags, struct winreg_RestoreKey *r)
2648 {
2649         TALLOC_CTX *_mem_save_handle_0;
2650         TALLOC_CTX *_mem_save_filename_0;
2651         if (flags & NDR_IN) {
2652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2653                         NDR_PULL_ALLOC(ndr, r->in.handle);
2654                 }
2655                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2656                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2657                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2659                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2660                         NDR_PULL_ALLOC(ndr, r->in.filename);
2661                 }
2662                 _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2663                 NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
2664                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2665                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
2666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
2667         }
2668         if (flags & NDR_OUT) {
2669                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2670         }
2671         return NT_STATUS_OK;
2672 }
2673
2674 _PUBLIC_ void ndr_print_winreg_RestoreKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_RestoreKey *r)
2675 {
2676         ndr_print_struct(ndr, name, "winreg_RestoreKey");
2677         ndr->depth++;
2678         if (flags & NDR_SET_VALUES) {
2679                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2680         }
2681         if (flags & NDR_IN) {
2682                 ndr_print_struct(ndr, "in", "winreg_RestoreKey");
2683                 ndr->depth++;
2684                 ndr_print_ptr(ndr, "handle", r->in.handle);
2685                 ndr->depth++;
2686                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2687                 ndr->depth--;
2688                 ndr_print_ptr(ndr, "filename", r->in.filename);
2689                 ndr->depth++;
2690                 ndr_print_winreg_String(ndr, "filename", r->in.filename);
2691                 ndr->depth--;
2692                 ndr_print_uint32(ndr, "flags", r->in.flags);
2693                 ndr->depth--;
2694         }
2695         if (flags & NDR_OUT) {
2696                 ndr_print_struct(ndr, "out", "winreg_RestoreKey");
2697                 ndr->depth++;
2698                 ndr_print_WERROR(ndr, "result", r->out.result);
2699                 ndr->depth--;
2700         }
2701         ndr->depth--;
2702 }
2703
2704 NTSTATUS ndr_push_winreg_SaveKey(struct ndr_push *ndr, int flags, const struct winreg_SaveKey *r)
2705 {
2706         if (flags & NDR_IN) {
2707                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2709                 if (r->in.filename == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2710                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sec_attrib));
2712                 if (r->in.sec_attrib) {
2713                         NDR_CHECK(ndr_push_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
2714                 }
2715         }
2716         if (flags & NDR_OUT) {
2717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2718         }
2719         return NT_STATUS_OK;
2720 }
2721
2722 NTSTATUS ndr_pull_winreg_SaveKey(struct ndr_pull *ndr, int flags, struct winreg_SaveKey *r)
2723 {
2724         uint32_t _ptr_sec_attrib;
2725         TALLOC_CTX *_mem_save_handle_0;
2726         TALLOC_CTX *_mem_save_filename_0;
2727         TALLOC_CTX *_mem_save_sec_attrib_0;
2728         if (flags & NDR_IN) {
2729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2730                         NDR_PULL_ALLOC(ndr, r->in.handle);
2731                 }
2732                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2733                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2734                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2737                         NDR_PULL_ALLOC(ndr, r->in.filename);
2738                 }
2739                 _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
2741                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
2743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_attrib));
2744                 if (_ptr_sec_attrib) {
2745                         NDR_PULL_ALLOC(ndr, r->in.sec_attrib);
2746                 } else {
2747                         r->in.sec_attrib = NULL;
2748                 }
2749                 if (r->in.sec_attrib) {
2750                         _mem_save_sec_attrib_0 = NDR_PULL_GET_MEM_CTX(ndr);
2751                         NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_attrib, 0);
2752                         NDR_CHECK(ndr_pull_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
2753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_attrib_0, 0);
2754                 }
2755         }
2756         if (flags & NDR_OUT) {
2757                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2758         }
2759         return NT_STATUS_OK;
2760 }
2761
2762 _PUBLIC_ void ndr_print_winreg_SaveKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKey *r)
2763 {
2764         ndr_print_struct(ndr, name, "winreg_SaveKey");
2765         ndr->depth++;
2766         if (flags & NDR_SET_VALUES) {
2767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2768         }
2769         if (flags & NDR_IN) {
2770                 ndr_print_struct(ndr, "in", "winreg_SaveKey");
2771                 ndr->depth++;
2772                 ndr_print_ptr(ndr, "handle", r->in.handle);
2773                 ndr->depth++;
2774                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2775                 ndr->depth--;
2776                 ndr_print_ptr(ndr, "filename", r->in.filename);
2777                 ndr->depth++;
2778                 ndr_print_winreg_String(ndr, "filename", r->in.filename);
2779                 ndr->depth--;
2780                 ndr_print_ptr(ndr, "sec_attrib", r->in.sec_attrib);
2781                 ndr->depth++;
2782                 if (r->in.sec_attrib) {
2783                         ndr_print_KeySecurityAttribute(ndr, "sec_attrib", r->in.sec_attrib);
2784                 }
2785                 ndr->depth--;
2786                 ndr->depth--;
2787         }
2788         if (flags & NDR_OUT) {
2789                 ndr_print_struct(ndr, "out", "winreg_SaveKey");
2790                 ndr->depth++;
2791                 ndr_print_WERROR(ndr, "result", r->out.result);
2792                 ndr->depth--;
2793         }
2794         ndr->depth--;
2795 }
2796
2797 NTSTATUS ndr_push_winreg_SetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_SetKeySecurity *r)
2798 {
2799         if (flags & NDR_IN) {
2800                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2801                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2802                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
2803                 if (r->in.sd == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2804                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
2805         }
2806         if (flags & NDR_OUT) {
2807                 if (r->out.sd == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2808                 NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
2809                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2810         }
2811         return NT_STATUS_OK;
2812 }
2813
2814 NTSTATUS ndr_pull_winreg_SetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_SetKeySecurity *r)
2815 {
2816         TALLOC_CTX *_mem_save_handle_0;
2817         TALLOC_CTX *_mem_save_sd_0;
2818         if (flags & NDR_IN) {
2819                 ZERO_STRUCT(r->out);
2820
2821                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2822                         NDR_PULL_ALLOC(ndr, r->in.handle);
2823                 }
2824                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2825                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2826                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2828                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
2829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2830                         NDR_PULL_ALLOC(ndr, r->in.sd);
2831                 }
2832                 _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
2833                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);
2834                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
2835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
2836                 NDR_PULL_ALLOC(ndr, r->out.sd);
2837                 *r->out.sd = *r->in.sd;
2838         }
2839         if (flags & NDR_OUT) {
2840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2841                         NDR_PULL_ALLOC(ndr, r->out.sd);
2842                 }
2843                 _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sd, LIBNDR_FLAG_REF_ALLOC);
2845                 NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
2846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
2847                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2848         }
2849         return NT_STATUS_OK;
2850 }
2851
2852 _PUBLIC_ void ndr_print_winreg_SetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetKeySecurity *r)
2853 {
2854         ndr_print_struct(ndr, name, "winreg_SetKeySecurity");
2855         ndr->depth++;
2856         if (flags & NDR_SET_VALUES) {
2857                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2858         }
2859         if (flags & NDR_IN) {
2860                 ndr_print_struct(ndr, "in", "winreg_SetKeySecurity");
2861                 ndr->depth++;
2862                 ndr_print_ptr(ndr, "handle", r->in.handle);
2863                 ndr->depth++;
2864                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2865                 ndr->depth--;
2866                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
2867                 ndr_print_ptr(ndr, "sd", r->in.sd);
2868                 ndr->depth++;
2869                 ndr_print_KeySecurityData(ndr, "sd", r->in.sd);
2870                 ndr->depth--;
2871                 ndr->depth--;
2872         }
2873         if (flags & NDR_OUT) {
2874                 ndr_print_struct(ndr, "out", "winreg_SetKeySecurity");
2875                 ndr->depth++;
2876                 ndr_print_ptr(ndr, "sd", r->out.sd);
2877                 ndr->depth++;
2878                 ndr_print_KeySecurityData(ndr, "sd", r->out.sd);
2879                 ndr->depth--;
2880                 ndr_print_WERROR(ndr, "result", r->out.result);
2881                 ndr->depth--;
2882         }
2883         ndr->depth--;
2884 }
2885
2886 NTSTATUS ndr_push_winreg_SetValue(struct ndr_push *ndr, int flags, const struct winreg_SetValue *r)
2887 {
2888         if (flags & NDR_IN) {
2889                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2890                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2891                 NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
2892                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
2893                 if (r->in.data == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));
2895                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.size));
2896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));
2897         }
2898         if (flags & NDR_OUT) {
2899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2900         }
2901         return NT_STATUS_OK;
2902 }
2903
2904 NTSTATUS ndr_pull_winreg_SetValue(struct ndr_pull *ndr, int flags, struct winreg_SetValue *r)
2905 {
2906         TALLOC_CTX *_mem_save_handle_0;
2907         if (flags & NDR_IN) {
2908                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2909                         NDR_PULL_ALLOC(ndr, r->in.handle);
2910                 }
2911                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2912                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2913                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2914                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2915                 NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
2916                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
2917                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
2918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2919                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
2920                 }
2921                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
2922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.size));
2923                 if (r->in.data) {
2924                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.size));
2925                 }
2926         }
2927         if (flags & NDR_OUT) {
2928                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2929         }
2930         return NT_STATUS_OK;
2931 }
2932
2933 _PUBLIC_ void ndr_print_winreg_SetValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetValue *r)
2934 {
2935         ndr_print_struct(ndr, name, "winreg_SetValue");
2936         ndr->depth++;
2937         if (flags & NDR_SET_VALUES) {
2938                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2939         }
2940         if (flags & NDR_IN) {
2941                 ndr_print_struct(ndr, "in", "winreg_SetValue");
2942                 ndr->depth++;
2943                 ndr_print_ptr(ndr, "handle", r->in.handle);
2944                 ndr->depth++;
2945                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2946                 ndr->depth--;
2947                 ndr_print_winreg_String(ndr, "name", &r->in.name);
2948                 ndr_print_winreg_Type(ndr, "type", r->in.type);
2949                 ndr_print_ptr(ndr, "data", r->in.data);
2950                 ndr->depth++;
2951                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.size);
2952                 ndr->depth--;
2953                 ndr_print_uint32(ndr, "size", r->in.size);
2954                 ndr->depth--;
2955         }
2956         if (flags & NDR_OUT) {
2957                 ndr_print_struct(ndr, "out", "winreg_SetValue");
2958                 ndr->depth++;
2959                 ndr_print_WERROR(ndr, "result", r->out.result);
2960                 ndr->depth--;
2961         }
2962         ndr->depth--;
2963 }
2964
2965 NTSTATUS ndr_push_winreg_UnLoadKey(struct ndr_push *ndr, int flags, const struct winreg_UnLoadKey *r)
2966 {
2967         if (flags & NDR_IN) {
2968         }
2969         if (flags & NDR_OUT) {
2970                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2971         }
2972         return NT_STATUS_OK;
2973 }
2974
2975 NTSTATUS ndr_pull_winreg_UnLoadKey(struct ndr_pull *ndr, int flags, struct winreg_UnLoadKey *r)
2976 {
2977         if (flags & NDR_IN) {
2978         }
2979         if (flags & NDR_OUT) {
2980                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2981         }
2982         return NT_STATUS_OK;
2983 }
2984
2985 _PUBLIC_ void ndr_print_winreg_UnLoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_UnLoadKey *r)
2986 {
2987         ndr_print_struct(ndr, name, "winreg_UnLoadKey");
2988         ndr->depth++;
2989         if (flags & NDR_SET_VALUES) {
2990                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2991         }
2992         if (flags & NDR_IN) {
2993                 ndr_print_struct(ndr, "in", "winreg_UnLoadKey");
2994                 ndr->depth++;
2995                 ndr->depth--;
2996         }
2997         if (flags & NDR_OUT) {
2998                 ndr_print_struct(ndr, "out", "winreg_UnLoadKey");
2999                 ndr->depth++;
3000                 ndr_print_WERROR(ndr, "result", r->out.result);
3001                 ndr->depth--;
3002         }
3003         ndr->depth--;
3004 }
3005
3006 NTSTATUS ndr_push_winreg_InitiateSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdown *r)
3007 {
3008         if (flags & NDR_IN) {
3009                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));
3010                 if (r->in.hostname) {
3011                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));
3012                 }
3013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));
3014                 if (r->in.message) {
3015                         NDR_CHECK(ndr_push_initshutdown_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3016                 }
3017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));
3018                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));
3019                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.reboot));
3020         }
3021         if (flags & NDR_OUT) {
3022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3023         }
3024         return NT_STATUS_OK;
3025 }
3026
3027 NTSTATUS ndr_pull_winreg_InitiateSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdown *r)
3028 {
3029         uint32_t _ptr_hostname;
3030         uint32_t _ptr_message;
3031         TALLOC_CTX *_mem_save_hostname_0;
3032         TALLOC_CTX *_mem_save_message_0;
3033         if (flags & NDR_IN) {
3034                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));
3035                 if (_ptr_hostname) {
3036                         NDR_PULL_ALLOC(ndr, r->in.hostname);
3037                 } else {
3038                         r->in.hostname = NULL;
3039                 }
3040                 if (r->in.hostname) {
3041                         _mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3042                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);
3043                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));
3044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);
3045                 }
3046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));
3047                 if (_ptr_message) {
3048                         NDR_PULL_ALLOC(ndr, r->in.message);
3049                 } else {
3050                         r->in.message = NULL;
3051                 }
3052                 if (r->in.message) {
3053                         _mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);
3054                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);
3055                         NDR_CHECK(ndr_pull_initshutdown_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);
3057                 }
3058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));
3059                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));
3060                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.reboot));
3061         }
3062         if (flags & NDR_OUT) {
3063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3064         }
3065         return NT_STATUS_OK;
3066 }
3067
3068 _PUBLIC_ void ndr_print_winreg_InitiateSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdown *r)
3069 {
3070         ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdown");
3071         ndr->depth++;
3072         if (flags & NDR_SET_VALUES) {
3073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3074         }
3075         if (flags & NDR_IN) {
3076                 ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdown");
3077                 ndr->depth++;
3078                 ndr_print_ptr(ndr, "hostname", r->in.hostname);
3079                 ndr->depth++;
3080                 if (r->in.hostname) {
3081                         ndr_print_uint16(ndr, "hostname", *r->in.hostname);
3082                 }
3083                 ndr->depth--;
3084                 ndr_print_ptr(ndr, "message", r->in.message);
3085                 ndr->depth++;
3086                 if (r->in.message) {
3087                         ndr_print_initshutdown_String(ndr, "message", r->in.message);
3088                 }
3089                 ndr->depth--;
3090                 ndr_print_uint32(ndr, "timeout", r->in.timeout);
3091                 ndr_print_uint8(ndr, "force_apps", r->in.force_apps);
3092                 ndr_print_uint8(ndr, "reboot", r->in.reboot);
3093                 ndr->depth--;
3094         }
3095         if (flags & NDR_OUT) {
3096                 ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdown");
3097                 ndr->depth++;
3098                 ndr_print_WERROR(ndr, "result", r->out.result);
3099                 ndr->depth--;
3100         }
3101         ndr->depth--;
3102 }
3103
3104 NTSTATUS ndr_push_winreg_AbortSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_AbortSystemShutdown *r)
3105 {
3106         if (flags & NDR_IN) {
3107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
3108                 if (r->in.server) {
3109                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.server));
3110                 }
3111         }
3112         if (flags & NDR_OUT) {
3113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3114         }
3115         return NT_STATUS_OK;
3116 }
3117
3118 NTSTATUS ndr_pull_winreg_AbortSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_AbortSystemShutdown *r)
3119 {
3120         uint32_t _ptr_server;
3121         TALLOC_CTX *_mem_save_server_0;
3122         if (flags & NDR_IN) {
3123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
3124                 if (_ptr_server) {
3125                         NDR_PULL_ALLOC(ndr, r->in.server);
3126                 } else {
3127                         r->in.server = NULL;
3128                 }
3129                 if (r->in.server) {
3130                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3131                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
3132                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.server));
3133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
3134                 }
3135         }
3136         if (flags & NDR_OUT) {
3137                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3138         }
3139         return NT_STATUS_OK;
3140 }
3141
3142 _PUBLIC_ void ndr_print_winreg_AbortSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_AbortSystemShutdown *r)
3143 {
3144         ndr_print_struct(ndr, name, "winreg_AbortSystemShutdown");
3145         ndr->depth++;
3146         if (flags & NDR_SET_VALUES) {
3147                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3148         }
3149         if (flags & NDR_IN) {
3150                 ndr_print_struct(ndr, "in", "winreg_AbortSystemShutdown");
3151                 ndr->depth++;
3152                 ndr_print_ptr(ndr, "server", r->in.server);
3153                 ndr->depth++;
3154                 if (r->in.server) {
3155                         ndr_print_uint16(ndr, "server", *r->in.server);
3156                 }
3157                 ndr->depth--;
3158                 ndr->depth--;
3159         }
3160         if (flags & NDR_OUT) {
3161                 ndr_print_struct(ndr, "out", "winreg_AbortSystemShutdown");
3162                 ndr->depth++;
3163                 ndr_print_WERROR(ndr, "result", r->out.result);
3164                 ndr->depth--;
3165         }
3166         ndr->depth--;
3167 }
3168
3169 NTSTATUS ndr_push_winreg_GetVersion(struct ndr_push *ndr, int flags, const struct winreg_GetVersion *r)
3170 {
3171         if (flags & NDR_IN) {
3172                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3173                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3174         }
3175         if (flags & NDR_OUT) {
3176                 if (r->out.version == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.version));
3178                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3179         }
3180         return NT_STATUS_OK;
3181 }
3182
3183 NTSTATUS ndr_pull_winreg_GetVersion(struct ndr_pull *ndr, int flags, struct winreg_GetVersion *r)
3184 {
3185         TALLOC_CTX *_mem_save_handle_0;
3186         TALLOC_CTX *_mem_save_version_0;
3187         if (flags & NDR_IN) {
3188                 ZERO_STRUCT(r->out);
3189
3190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3191                         NDR_PULL_ALLOC(ndr, r->in.handle);
3192                 }
3193                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3195                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3197                 NDR_PULL_ALLOC(ndr, r->out.version);
3198                 ZERO_STRUCTP(r->out.version);
3199         }
3200         if (flags & NDR_OUT) {
3201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3202                         NDR_PULL_ALLOC(ndr, r->out.version);
3203                 }
3204                 _mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
3205                 NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);
3206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.version));
3207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);
3208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3209         }
3210         return NT_STATUS_OK;
3211 }
3212
3213 _PUBLIC_ void ndr_print_winreg_GetVersion(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetVersion *r)
3214 {
3215         ndr_print_struct(ndr, name, "winreg_GetVersion");
3216         ndr->depth++;
3217         if (flags & NDR_SET_VALUES) {
3218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3219         }
3220         if (flags & NDR_IN) {
3221                 ndr_print_struct(ndr, "in", "winreg_GetVersion");
3222                 ndr->depth++;
3223                 ndr_print_ptr(ndr, "handle", r->in.handle);
3224                 ndr->depth++;
3225                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3226                 ndr->depth--;
3227                 ndr->depth--;
3228         }
3229         if (flags & NDR_OUT) {
3230                 ndr_print_struct(ndr, "out", "winreg_GetVersion");
3231                 ndr->depth++;
3232                 ndr_print_ptr(ndr, "version", r->out.version);
3233                 ndr->depth++;
3234                 ndr_print_uint32(ndr, "version", *r->out.version);
3235                 ndr->depth--;
3236                 ndr_print_WERROR(ndr, "result", r->out.result);
3237                 ndr->depth--;
3238         }
3239         ndr->depth--;
3240 }
3241
3242 NTSTATUS ndr_push_winreg_OpenHKCC(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCC *r)
3243 {
3244         if (flags & NDR_IN) {
3245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3246                 if (r->in.system_name) {
3247                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3248                 }
3249                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3250         }
3251         if (flags & NDR_OUT) {
3252                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3253                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3255         }
3256         return NT_STATUS_OK;
3257 }
3258
3259 NTSTATUS ndr_pull_winreg_OpenHKCC(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCC *r)
3260 {
3261         uint32_t _ptr_system_name;
3262         TALLOC_CTX *_mem_save_system_name_0;
3263         TALLOC_CTX *_mem_save_handle_0;
3264         if (flags & NDR_IN) {
3265                 ZERO_STRUCT(r->out);
3266
3267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3268                 if (_ptr_system_name) {
3269                         NDR_PULL_ALLOC(ndr, r->in.system_name);
3270                 } else {
3271                         r->in.system_name = NULL;
3272                 }
3273                 if (r->in.system_name) {
3274                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3275                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3276                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3277                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3278                 }
3279                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3280                 NDR_PULL_ALLOC(ndr, r->out.handle);
3281                 ZERO_STRUCTP(r->out.handle);
3282         }
3283         if (flags & NDR_OUT) {
3284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3285                         NDR_PULL_ALLOC(ndr, r->out.handle);
3286                 }
3287                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3288                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3289                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3292         }
3293         return NT_STATUS_OK;
3294 }
3295
3296 _PUBLIC_ void ndr_print_winreg_OpenHKCC(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCC *r)
3297 {
3298         ndr_print_struct(ndr, name, "winreg_OpenHKCC");
3299         ndr->depth++;
3300         if (flags & NDR_SET_VALUES) {
3301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3302         }
3303         if (flags & NDR_IN) {
3304                 ndr_print_struct(ndr, "in", "winreg_OpenHKCC");
3305                 ndr->depth++;
3306                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
3307                 ndr->depth++;
3308                 if (r->in.system_name) {
3309                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3310                 }
3311                 ndr->depth--;
3312                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3313                 ndr->depth--;
3314         }
3315         if (flags & NDR_OUT) {
3316                 ndr_print_struct(ndr, "out", "winreg_OpenHKCC");
3317                 ndr->depth++;
3318                 ndr_print_ptr(ndr, "handle", r->out.handle);
3319                 ndr->depth++;
3320                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3321                 ndr->depth--;
3322                 ndr_print_WERROR(ndr, "result", r->out.result);
3323                 ndr->depth--;
3324         }
3325         ndr->depth--;
3326 }
3327
3328 NTSTATUS ndr_push_winreg_OpenHKDD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKDD *r)
3329 {
3330         if (flags & NDR_IN) {
3331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3332                 if (r->in.system_name) {
3333                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3334                 }
3335                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3336         }
3337         if (flags & NDR_OUT) {
3338                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3339                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3341         }
3342         return NT_STATUS_OK;
3343 }
3344
3345 NTSTATUS ndr_pull_winreg_OpenHKDD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKDD *r)
3346 {
3347         uint32_t _ptr_system_name;
3348         TALLOC_CTX *_mem_save_system_name_0;
3349         TALLOC_CTX *_mem_save_handle_0;
3350         if (flags & NDR_IN) {
3351                 ZERO_STRUCT(r->out);
3352
3353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3354                 if (_ptr_system_name) {
3355                         NDR_PULL_ALLOC(ndr, r->in.system_name);
3356                 } else {
3357                         r->in.system_name = NULL;
3358                 }
3359                 if (r->in.system_name) {
3360                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3361                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3362                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3364                 }
3365                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3366                 NDR_PULL_ALLOC(ndr, r->out.handle);
3367                 ZERO_STRUCTP(r->out.handle);
3368         }
3369         if (flags & NDR_OUT) {
3370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3371                         NDR_PULL_ALLOC(ndr, r->out.handle);
3372                 }
3373                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3374                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3375                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3377                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3378         }
3379         return NT_STATUS_OK;
3380 }
3381
3382 _PUBLIC_ void ndr_print_winreg_OpenHKDD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKDD *r)
3383 {
3384         ndr_print_struct(ndr, name, "winreg_OpenHKDD");
3385         ndr->depth++;
3386         if (flags & NDR_SET_VALUES) {
3387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3388         }
3389         if (flags & NDR_IN) {
3390                 ndr_print_struct(ndr, "in", "winreg_OpenHKDD");
3391                 ndr->depth++;
3392                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
3393                 ndr->depth++;
3394                 if (r->in.system_name) {
3395                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3396                 }
3397                 ndr->depth--;
3398                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3399                 ndr->depth--;
3400         }
3401         if (flags & NDR_OUT) {
3402                 ndr_print_struct(ndr, "out", "winreg_OpenHKDD");
3403                 ndr->depth++;
3404                 ndr_print_ptr(ndr, "handle", r->out.handle);
3405                 ndr->depth++;
3406                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3407                 ndr->depth--;
3408                 ndr_print_WERROR(ndr, "result", r->out.result);
3409                 ndr->depth--;
3410         }
3411         ndr->depth--;
3412 }
3413
3414 NTSTATUS ndr_push_winreg_QueryMultipleValues(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues *r)
3415 {
3416         uint32_t cntr_values_1;
3417         if (flags & NDR_IN) {
3418                 if (r->in.key_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3419                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.key_handle));
3420                 if (r->in.values == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
3422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
3424                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3425                         NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values[cntr_values_1]));
3426                 }
3427                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3428                         NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values[cntr_values_1]));
3429                 }
3430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
3431                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
3432                 if (r->in.buffer) {
3433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));
3434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));
3436                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, *r->in.buffer_size));
3437                 }
3438                 if (r->in.buffer_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));
3440         }
3441         if (flags & NDR_OUT) {
3442                 if (r->out.values == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
3444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
3446                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3447                         NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values[cntr_values_1]));
3448                 }
3449                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3450                         NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values[cntr_values_1]));
3451                 }
3452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
3453                 if (r->out.buffer) {
3454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));
3455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));
3457                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, *r->out.buffer_size));
3458                 }
3459                 if (r->out.buffer_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));
3461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3462         }
3463         return NT_STATUS_OK;
3464 }
3465
3466 NTSTATUS ndr_pull_winreg_QueryMultipleValues(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues *r)
3467 {
3468         uint32_t cntr_values_1;
3469         uint32_t _ptr_buffer;
3470         TALLOC_CTX *_mem_save_key_handle_0;
3471         TALLOC_CTX *_mem_save_values_1;
3472         TALLOC_CTX *_mem_save_buffer_0;
3473         TALLOC_CTX *_mem_save_buffer_size_0;
3474         if (flags & NDR_IN) {
3475                 ZERO_STRUCT(r->out);
3476
3477                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3478                         NDR_PULL_ALLOC(ndr, r->in.key_handle);
3479                 }
3480                 _mem_save_key_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3481                 NDR_PULL_SET_MEM_CTX(ndr, r->in.key_handle, LIBNDR_FLAG_REF_ALLOC);
3482                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.key_handle));
3483                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_handle_0, LIBNDR_FLAG_REF_ALLOC);
3484                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.values));
3485                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.values));
3486                 if (ndr_get_array_length(ndr, &r->in.values) > ndr_get_array_size(ndr, &r->in.values)) {
3487                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.values), ndr_get_array_length(ndr, &r->in.values));
3488                 }
3489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3490                         NDR_PULL_ALLOC_N(ndr, r->in.values, ndr_get_array_size(ndr, &r->in.values));
3491                 }
3492                 memcpy(r->out.values,r->in.values,ndr_get_array_size(ndr, &r->in.values) * sizeof(*r->in.values));
3493                 _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
3494                 NDR_PULL_SET_MEM_CTX(ndr, r->in.values, 0);
3495                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3496                         NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values[cntr_values_1]));
3497                 }
3498                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3499                         NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values[cntr_values_1]));
3500                 }
3501                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
3502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_values));
3503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
3504                 if (_ptr_buffer) {
3505                         NDR_PULL_ALLOC(ndr, r->in.buffer);
3506                 } else {
3507                         r->in.buffer = NULL;
3508                 }
3509                 if (r->in.buffer) {
3510                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
3511                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
3512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
3513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.buffer));
3514                         if (ndr_get_array_length(ndr, &r->in.buffer) > ndr_get_array_size(ndr, &r->in.buffer)) {
3515                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.buffer), ndr_get_array_length(ndr, &r->in.buffer));
3516                         }
3517                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
3518                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_length(ndr, &r->in.buffer)));
3519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
3520                 }
3521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3522                         NDR_PULL_ALLOC(ndr, r->in.buffer_size);
3523                 }
3524                 _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
3525                 NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer_size, LIBNDR_FLAG_REF_ALLOC);
3526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
3527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
3528                 NDR_PULL_ALLOC_N(ndr, r->out.values, r->in.num_values);
3529                 memcpy(r->out.values, r->in.values, r->in.num_values * sizeof(*r->in.values));
3530                 NDR_PULL_ALLOC(ndr, r->out.buffer_size);
3531                 *r->out.buffer_size = *r->in.buffer_size;
3532                 if (r->in.values) {
3533                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.values, r->in.num_values));
3534                 }
3535                 if (r->in.values) {
3536                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.values, r->in.num_values));
3537                 }
3538                 if (r->in.buffer) {
3539                         if (r->in.buffer_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3540                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, *r->in.buffer_size));
3541                 }
3542                 if (r->in.buffer) {
3543                         if (r->in.buffer_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3544                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.buffer, *r->in.buffer_size));
3545                 }
3546         }
3547         if (flags & NDR_OUT) {
3548                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.values));
3549                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.values));
3550                 if (ndr_get_array_length(ndr, &r->out.values) > ndr_get_array_size(ndr, &r->out.values)) {
3551                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.values), ndr_get_array_length(ndr, &r->out.values));
3552                 }
3553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3554                         NDR_PULL_ALLOC_N(ndr, r->out.values, ndr_get_array_size(ndr, &r->out.values));
3555                 }
3556                 memcpy(r->out.values,r->in.values,ndr_get_array_size(ndr, &r->out.values) * sizeof(*r->in.values));
3557                 _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
3558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.values, 0);
3559                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3560                         NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values[cntr_values_1]));
3561                 }
3562                 for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3563                         NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values[cntr_values_1]));
3564                 }
3565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
3566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
3567                 if (_ptr_buffer) {
3568                         NDR_PULL_ALLOC(ndr, r->out.buffer);
3569                 } else {
3570                         r->out.buffer = NULL;
3571                 }
3572                 if (r->out.buffer) {
3573                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
3574                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
3575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
3576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));
3577                         if (ndr_get_array_length(ndr, &r->out.buffer) > ndr_get_array_size(ndr, &r->out.buffer)) {
3578                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.buffer), ndr_get_array_length(ndr, &r->out.buffer));
3579                         }
3580                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
3581                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_length(ndr, &r->out.buffer)));
3582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
3583                 }
3584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3585                         NDR_PULL_ALLOC(ndr, r->out.buffer_size);
3586                 }
3587                 _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
3588                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer_size, LIBNDR_FLAG_REF_ALLOC);
3589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.buffer_size));
3590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
3591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3592                 if (r->out.values) {
3593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.values, r->in.num_values));
3594                 }
3595                 if (r->out.values) {
3596                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.values, r->in.num_values));
3597                 }
3598                 if (r->out.buffer) {
3599                         if (r->out.buffer_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3600                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
3601                 }
3602                 if (r->out.buffer) {
3603                         if (r->out.buffer_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3604                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
3605                 }
3606         }
3607         return NT_STATUS_OK;
3608 }
3609
3610 _PUBLIC_ void ndr_print_winreg_QueryMultipleValues(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues *r)
3611 {
3612         uint32_t cntr_values_1;
3613         ndr_print_struct(ndr, name, "winreg_QueryMultipleValues");
3614         ndr->depth++;
3615         if (flags & NDR_SET_VALUES) {
3616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3617         }
3618         if (flags & NDR_IN) {
3619                 ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues");
3620                 ndr->depth++;
3621                 ndr_print_ptr(ndr, "key_handle", r->in.key_handle);
3622                 ndr->depth++;
3623                 ndr_print_policy_handle(ndr, "key_handle", r->in.key_handle);
3624                 ndr->depth--;
3625                 ndr_print_ptr(ndr, "values", r->in.values);
3626                 ndr->depth++;
3627                 ndr->print(ndr, "%s: ARRAY(%d)", "values", r->in.num_values);
3628                 ndr->depth++;
3629                 for (cntr_values_1=0;cntr_values_1<r->in.num_values;cntr_values_1++) {
3630                         char *idx_1=NULL;
3631                         asprintf(&idx_1, "[%d]", cntr_values_1);
3632                         if (idx_1) {
3633                                 ndr_print_QueryMultipleValue(ndr, "values", &r->in.values[cntr_values_1]);
3634                                 free(idx_1);
3635                         }
3636                 }
3637                 ndr->depth--;
3638                 ndr->depth--;
3639                 ndr_print_uint32(ndr, "num_values", r->in.num_values);
3640                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
3641                 ndr->depth++;
3642                 if (r->in.buffer) {
3643                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, *r->in.buffer_size);
3644                 }
3645                 ndr->depth--;
3646                 ndr_print_ptr(ndr, "buffer_size", r->in.buffer_size);
3647                 ndr->depth++;
3648                 ndr_print_uint32(ndr, "buffer_size", *r->in.buffer_size);
3649                 ndr->depth--;
3650                 ndr->depth--;
3651         }
3652         if (flags & NDR_OUT) {
3653                 ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues");
3654                 ndr->depth++;
3655                 ndr_print_ptr(ndr, "values", r->out.values);
3656                 ndr->depth++;
3657                 ndr->print(ndr, "%s: ARRAY(%d)", "values", r->in.num_values);
3658                 ndr->depth++;
3659                 for (cntr_values_1=0;cntr_values_1<r->in.num_values;cntr_values_1++) {
3660                         char *idx_1=NULL;
3661                         asprintf(&idx_1, "[%d]", cntr_values_1);
3662                         if (idx_1) {
3663                                 ndr_print_QueryMultipleValue(ndr, "values", &r->out.values[cntr_values_1]);
3664                                 free(idx_1);
3665                         }
3666                 }
3667                 ndr->depth--;
3668                 ndr->depth--;
3669                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
3670                 ndr->depth++;
3671                 if (r->out.buffer) {
3672                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, *r->out.buffer_size);
3673                 }
3674                 ndr->depth--;
3675                 ndr_print_ptr(ndr, "buffer_size", r->out.buffer_size);
3676                 ndr->depth++;
3677                 ndr_print_uint32(ndr, "buffer_size", *r->out.buffer_size);
3678                 ndr->depth--;
3679                 ndr_print_WERROR(ndr, "result", r->out.result);
3680                 ndr->depth--;
3681         }
3682         ndr->depth--;
3683 }
3684
3685 NTSTATUS ndr_push_winreg_InitiateSystemShutdownEx(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdownEx *r)
3686 {
3687         if (flags & NDR_IN) {
3688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));
3689                 if (r->in.hostname) {
3690                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));
3691                 }
3692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));
3693                 if (r->in.message) {
3694                         NDR_CHECK(ndr_push_initshutdown_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3695                 }
3696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));
3697                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));
3698                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.reboot));
3699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reason));
3700         }
3701         if (flags & NDR_OUT) {
3702                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3703         }
3704         return NT_STATUS_OK;
3705 }
3706
3707 NTSTATUS ndr_pull_winreg_InitiateSystemShutdownEx(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdownEx *r)
3708 {
3709         uint32_t _ptr_hostname;
3710         uint32_t _ptr_message;
3711         TALLOC_CTX *_mem_save_hostname_0;
3712         TALLOC_CTX *_mem_save_message_0;
3713         if (flags & NDR_IN) {
3714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));
3715                 if (_ptr_hostname) {
3716                         NDR_PULL_ALLOC(ndr, r->in.hostname);
3717                 } else {
3718                         r->in.hostname = NULL;
3719                 }
3720                 if (r->in.hostname) {
3721                         _mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3722                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);
3723                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));
3724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);
3725                 }
3726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));
3727                 if (_ptr_message) {
3728                         NDR_PULL_ALLOC(ndr, r->in.message);
3729                 } else {
3730                         r->in.message = NULL;
3731                 }
3732                 if (r->in.message) {
3733                         _mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);
3734                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);
3735                         NDR_CHECK(ndr_pull_initshutdown_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);
3737                 }
3738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));
3739                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));
3740                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.reboot));
3741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reason));
3742         }
3743         if (flags & NDR_OUT) {
3744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3745         }
3746         return NT_STATUS_OK;
3747 }
3748
3749 _PUBLIC_ void ndr_print_winreg_InitiateSystemShutdownEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdownEx *r)
3750 {
3751         ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdownEx");
3752         ndr->depth++;
3753         if (flags & NDR_SET_VALUES) {
3754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3755         }
3756         if (flags & NDR_IN) {
3757                 ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdownEx");
3758                 ndr->depth++;
3759                 ndr_print_ptr(ndr, "hostname", r->in.hostname);
3760                 ndr->depth++;
3761                 if (r->in.hostname) {
3762                         ndr_print_uint16(ndr, "hostname", *r->in.hostname);
3763                 }
3764                 ndr->depth--;
3765                 ndr_print_ptr(ndr, "message", r->in.message);
3766                 ndr->depth++;
3767                 if (r->in.message) {
3768                         ndr_print_initshutdown_String(ndr, "message", r->in.message);
3769                 }
3770                 ndr->depth--;
3771                 ndr_print_uint32(ndr, "timeout", r->in.timeout);
3772                 ndr_print_uint8(ndr, "force_apps", r->in.force_apps);
3773                 ndr_print_uint8(ndr, "reboot", r->in.reboot);
3774                 ndr_print_uint32(ndr, "reason", r->in.reason);
3775                 ndr->depth--;
3776         }
3777         if (flags & NDR_OUT) {
3778                 ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdownEx");
3779                 ndr->depth++;
3780                 ndr_print_WERROR(ndr, "result", r->out.result);
3781                 ndr->depth--;
3782         }
3783         ndr->depth--;
3784 }
3785
3786 NTSTATUS ndr_push_winreg_SaveKeyEx(struct ndr_push *ndr, int flags, const struct winreg_SaveKeyEx *r)
3787 {
3788         if (flags & NDR_IN) {
3789         }
3790         if (flags & NDR_OUT) {
3791                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3792         }
3793         return NT_STATUS_OK;
3794 }
3795
3796 NTSTATUS ndr_pull_winreg_SaveKeyEx(struct ndr_pull *ndr, int flags, struct winreg_SaveKeyEx *r)
3797 {
3798         if (flags & NDR_IN) {
3799         }
3800         if (flags & NDR_OUT) {
3801                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3802         }
3803         return NT_STATUS_OK;
3804 }
3805
3806 _PUBLIC_ void ndr_print_winreg_SaveKeyEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKeyEx *r)
3807 {
3808         ndr_print_struct(ndr, name, "winreg_SaveKeyEx");
3809         ndr->depth++;
3810         if (flags & NDR_SET_VALUES) {
3811                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3812         }
3813         if (flags & NDR_IN) {
3814                 ndr_print_struct(ndr, "in", "winreg_SaveKeyEx");
3815                 ndr->depth++;
3816                 ndr->depth--;
3817         }
3818         if (flags & NDR_OUT) {
3819                 ndr_print_struct(ndr, "out", "winreg_SaveKeyEx");
3820                 ndr->depth++;
3821                 ndr_print_WERROR(ndr, "result", r->out.result);
3822                 ndr->depth--;
3823         }
3824         ndr->depth--;
3825 }
3826
3827 NTSTATUS ndr_push_winreg_OpenHKPT(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPT *r)
3828 {
3829         if (flags & NDR_IN) {
3830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3831                 if (r->in.system_name) {
3832                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3833                 }
3834                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3835         }
3836         if (flags & NDR_OUT) {
3837                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3838                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3840         }
3841         return NT_STATUS_OK;
3842 }
3843
3844 NTSTATUS ndr_pull_winreg_OpenHKPT(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPT *r)
3845 {
3846         uint32_t _ptr_system_name;
3847         TALLOC_CTX *_mem_save_system_name_0;
3848         TALLOC_CTX *_mem_save_handle_0;
3849         if (flags & NDR_IN) {
3850                 ZERO_STRUCT(r->out);
3851
3852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3853                 if (_ptr_system_name) {
3854                         NDR_PULL_ALLOC(ndr, r->in.system_name);
3855                 } else {
3856                         r->in.system_name = NULL;
3857                 }
3858                 if (r->in.system_name) {
3859                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3860                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3861                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3863                 }
3864                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3865                 NDR_PULL_ALLOC(ndr, r->out.handle);
3866                 ZERO_STRUCTP(r->out.handle);
3867         }
3868         if (flags & NDR_OUT) {
3869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3870                         NDR_PULL_ALLOC(ndr, r->out.handle);
3871                 }
3872                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3873                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3874                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3876                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3877         }
3878         return NT_STATUS_OK;
3879 }
3880
3881 _PUBLIC_ void ndr_print_winreg_OpenHKPT(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPT *r)
3882 {
3883         ndr_print_struct(ndr, name, "winreg_OpenHKPT");
3884         ndr->depth++;
3885         if (flags & NDR_SET_VALUES) {
3886                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3887         }
3888         if (flags & NDR_IN) {
3889                 ndr_print_struct(ndr, "in", "winreg_OpenHKPT");
3890                 ndr->depth++;
3891                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
3892                 ndr->depth++;
3893                 if (r->in.system_name) {
3894                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3895                 }
3896                 ndr->depth--;
3897                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3898                 ndr->depth--;
3899         }
3900         if (flags & NDR_OUT) {
3901                 ndr_print_struct(ndr, "out", "winreg_OpenHKPT");
3902                 ndr->depth++;
3903                 ndr_print_ptr(ndr, "handle", r->out.handle);
3904                 ndr->depth++;
3905                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3906                 ndr->depth--;
3907                 ndr_print_WERROR(ndr, "result", r->out.result);
3908                 ndr->depth--;
3909         }
3910         ndr->depth--;
3911 }
3912
3913 NTSTATUS ndr_push_winreg_OpenHKPN(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPN *r)
3914 {
3915         if (flags & NDR_IN) {
3916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3917                 if (r->in.system_name) {
3918                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3919                 }
3920                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3921         }
3922         if (flags & NDR_OUT) {
3923                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3924                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3926         }
3927         return NT_STATUS_OK;
3928 }
3929
3930 NTSTATUS ndr_pull_winreg_OpenHKPN(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPN *r)
3931 {
3932         uint32_t _ptr_system_name;
3933         TALLOC_CTX *_mem_save_system_name_0;
3934         TALLOC_CTX *_mem_save_handle_0;
3935         if (flags & NDR_IN) {
3936                 ZERO_STRUCT(r->out);
3937
3938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3939                 if (_ptr_system_name) {
3940                         NDR_PULL_ALLOC(ndr, r->in.system_name);
3941                 } else {
3942                         r->in.system_name = NULL;
3943                 }
3944                 if (r->in.system_name) {
3945                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3946                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3947                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3949                 }
3950                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3951                 NDR_PULL_ALLOC(ndr, r->out.handle);
3952                 ZERO_STRUCTP(r->out.handle);
3953         }
3954         if (flags & NDR_OUT) {
3955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3956                         NDR_PULL_ALLOC(ndr, r->out.handle);
3957                 }
3958                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3959                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3960                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3963         }
3964         return NT_STATUS_OK;
3965 }
3966
3967 _PUBLIC_ void ndr_print_winreg_OpenHKPN(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPN *r)
3968 {
3969         ndr_print_struct(ndr, name, "winreg_OpenHKPN");
3970         ndr->depth++;
3971         if (flags & NDR_SET_VALUES) {
3972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3973         }
3974         if (flags & NDR_IN) {
3975                 ndr_print_struct(ndr, "in", "winreg_OpenHKPN");
3976                 ndr->depth++;
3977                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
3978                 ndr->depth++;
3979                 if (r->in.system_name) {
3980                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3981                 }
3982                 ndr->depth--;
3983                 ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3984                 ndr->depth--;
3985         }
3986         if (flags & NDR_OUT) {
3987                 ndr_print_struct(ndr, "out", "winreg_OpenHKPN");
3988                 ndr->depth++;
3989                 ndr_print_ptr(ndr, "handle", r->out.handle);
3990                 ndr->depth++;
3991                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3992                 ndr->depth--;
3993                 ndr_print_WERROR(ndr, "result", r->out.result);
3994                 ndr->depth--;
3995         }
3996         ndr->depth--;
3997 }
3998
3999 NTSTATUS ndr_push_winreg_QueryMultipleValues2(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues2 *r)
4000 {
4001         if (flags & NDR_IN) {
4002         }
4003         if (flags & NDR_OUT) {
4004                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4005         }
4006         return NT_STATUS_OK;
4007 }
4008
4009 NTSTATUS ndr_pull_winreg_QueryMultipleValues2(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues2 *r)
4010 {
4011         if (flags & NDR_IN) {
4012         }
4013         if (flags & NDR_OUT) {
4014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4015         }
4016         return NT_STATUS_OK;
4017 }
4018
4019 _PUBLIC_ void ndr_print_winreg_QueryMultipleValues2(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues2 *r)
4020 {
4021         ndr_print_struct(ndr, name, "winreg_QueryMultipleValues2");
4022         ndr->depth++;
4023         if (flags & NDR_SET_VALUES) {
4024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4025         }
4026         if (flags & NDR_IN) {
4027                 ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues2");
4028                 ndr->depth++;
4029                 ndr->depth--;
4030         }
4031         if (flags & NDR_OUT) {
4032                 ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues2");
4033                 ndr->depth++;
4034                 ndr_print_WERROR(ndr, "result", r->out.result);
4035                 ndr->depth--;
4036         }
4037         ndr->depth--;
4038 }
4039
4040 const struct dcerpc_interface_call winreg_calls[] = {
4041         {
4042                 "winreg_OpenHKCR",
4043                 sizeof(struct winreg_OpenHKCR),
4044                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCR,
4045                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCR,
4046                 (ndr_print_function_t) ndr_print_winreg_OpenHKCR,
4047                 False,
4048         },
4049         {
4050                 "winreg_OpenHKCU",
4051                 sizeof(struct winreg_OpenHKCU),
4052                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCU,
4053                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCU,
4054                 (ndr_print_function_t) ndr_print_winreg_OpenHKCU,
4055                 False,
4056         },
4057         {
4058                 "winreg_OpenHKLM",
4059                 sizeof(struct winreg_OpenHKLM),
4060                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKLM,
4061                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKLM,
4062                 (ndr_print_function_t) ndr_print_winreg_OpenHKLM,
4063                 False,
4064         },
4065         {
4066                 "winreg_OpenHKPD",
4067                 sizeof(struct winreg_OpenHKPD),
4068                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPD,
4069                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPD,
4070                 (ndr_print_function_t) ndr_print_winreg_OpenHKPD,
4071                 False,
4072         },
4073         {
4074                 "winreg_OpenHKU",
4075                 sizeof(struct winreg_OpenHKU),
4076                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKU,
4077                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKU,
4078                 (ndr_print_function_t) ndr_print_winreg_OpenHKU,
4079                 False,
4080         },
4081         {
4082                 "winreg_CloseKey",
4083                 sizeof(struct winreg_CloseKey),
4084                 (ndr_push_flags_fn_t) ndr_push_winreg_CloseKey,
4085                 (ndr_pull_flags_fn_t) ndr_pull_winreg_CloseKey,
4086                 (ndr_print_function_t) ndr_print_winreg_CloseKey,
4087                 False,
4088         },
4089         {
4090                 "winreg_CreateKey",
4091                 sizeof(struct winreg_CreateKey),
4092                 (ndr_push_flags_fn_t) ndr_push_winreg_CreateKey,
4093                 (ndr_pull_flags_fn_t) ndr_pull_winreg_CreateKey,
4094                 (ndr_print_function_t) ndr_print_winreg_CreateKey,
4095                 False,
4096         },
4097         {
4098                 "winreg_DeleteKey",
4099                 sizeof(struct winreg_DeleteKey),
4100                 (ndr_push_flags_fn_t) ndr_push_winreg_DeleteKey,
4101                 (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteKey,
4102                 (ndr_print_function_t) ndr_print_winreg_DeleteKey,
4103                 False,
4104         },
4105         {
4106                 "winreg_DeleteValue",
4107                 sizeof(struct winreg_DeleteValue),
4108                 (ndr_push_flags_fn_t) ndr_push_winreg_DeleteValue,
4109                 (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteValue,
4110                 (ndr_print_function_t) ndr_print_winreg_DeleteValue,
4111                 False,
4112         },
4113         {
4114                 "winreg_EnumKey",
4115                 sizeof(struct winreg_EnumKey),
4116                 (ndr_push_flags_fn_t) ndr_push_winreg_EnumKey,
4117                 (ndr_pull_flags_fn_t) ndr_pull_winreg_EnumKey,
4118                 (ndr_print_function_t) ndr_print_winreg_EnumKey,
4119                 False,
4120         },
4121         {
4122                 "winreg_EnumValue",
4123                 sizeof(struct winreg_EnumValue),
4124                 (ndr_push_flags_fn_t) ndr_push_winreg_EnumValue,
4125                 (ndr_pull_flags_fn_t) ndr_pull_winreg_EnumValue,
4126                 (ndr_print_function_t) ndr_print_winreg_EnumValue,
4127                 False,
4128         },
4129         {
4130                 "winreg_FlushKey",
4131                 sizeof(struct winreg_FlushKey),
4132                 (ndr_push_flags_fn_t) ndr_push_winreg_FlushKey,
4133                 (ndr_pull_flags_fn_t) ndr_pull_winreg_FlushKey,
4134                 (ndr_print_function_t) ndr_print_winreg_FlushKey,
4135                 False,
4136         },
4137         {
4138                 "winreg_GetKeySecurity",
4139                 sizeof(struct winreg_GetKeySecurity),
4140                 (ndr_push_flags_fn_t) ndr_push_winreg_GetKeySecurity,
4141                 (ndr_pull_flags_fn_t) ndr_pull_winreg_GetKeySecurity,
4142                 (ndr_print_function_t) ndr_print_winreg_GetKeySecurity,
4143                 False,
4144         },
4145         {
4146                 "winreg_LoadKey",
4147                 sizeof(struct winreg_LoadKey),
4148                 (ndr_push_flags_fn_t) ndr_push_winreg_LoadKey,
4149                 (ndr_pull_flags_fn_t) ndr_pull_winreg_LoadKey,
4150                 (ndr_print_function_t) ndr_print_winreg_LoadKey,
4151                 False,
4152         },
4153         {
4154                 "winreg_NotifyChangeKeyValue",
4155                 sizeof(struct winreg_NotifyChangeKeyValue),
4156                 (ndr_push_flags_fn_t) ndr_push_winreg_NotifyChangeKeyValue,
4157                 (ndr_pull_flags_fn_t) ndr_pull_winreg_NotifyChangeKeyValue,
4158                 (ndr_print_function_t) ndr_print_winreg_NotifyChangeKeyValue,
4159                 False,
4160         },
4161         {
4162                 "winreg_OpenKey",
4163                 sizeof(struct winreg_OpenKey),
4164                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenKey,
4165                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenKey,
4166                 (ndr_print_function_t) ndr_print_winreg_OpenKey,
4167                 False,
4168         },
4169         {
4170                 "winreg_QueryInfoKey",
4171                 sizeof(struct winreg_QueryInfoKey),
4172                 (ndr_push_flags_fn_t) ndr_push_winreg_QueryInfoKey,
4173                 (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryInfoKey,
4174                 (ndr_print_function_t) ndr_print_winreg_QueryInfoKey,
4175                 False,
4176         },
4177         {
4178                 "winreg_QueryValue",
4179                 sizeof(struct winreg_QueryValue),
4180                 (ndr_push_flags_fn_t) ndr_push_winreg_QueryValue,
4181                 (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryValue,
4182                 (ndr_print_function_t) ndr_print_winreg_QueryValue,
4183                 False,
4184         },
4185         {
4186                 "winreg_ReplaceKey",
4187                 sizeof(struct winreg_ReplaceKey),
4188                 (ndr_push_flags_fn_t) ndr_push_winreg_ReplaceKey,
4189                 (ndr_pull_flags_fn_t) ndr_pull_winreg_ReplaceKey,
4190                 (ndr_print_function_t) ndr_print_winreg_ReplaceKey,
4191                 False,
4192         },
4193         {
4194                 "winreg_RestoreKey",
4195                 sizeof(struct winreg_RestoreKey),
4196                 (ndr_push_flags_fn_t) ndr_push_winreg_RestoreKey,
4197                 (ndr_pull_flags_fn_t) ndr_pull_winreg_RestoreKey,
4198                 (ndr_print_function_t) ndr_print_winreg_RestoreKey,
4199                 False,
4200         },
4201         {
4202                 "winreg_SaveKey",
4203                 sizeof(struct winreg_SaveKey),
4204                 (ndr_push_flags_fn_t) ndr_push_winreg_SaveKey,
4205                 (ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKey,
4206                 (ndr_print_function_t) ndr_print_winreg_SaveKey,
4207                 False,
4208         },
4209         {
4210                 "winreg_SetKeySecurity",
4211                 sizeof(struct winreg_SetKeySecurity),
4212                 (ndr_push_flags_fn_t) ndr_push_winreg_SetKeySecurity,
4213                 (ndr_pull_flags_fn_t) ndr_pull_winreg_SetKeySecurity,
4214                 (ndr_print_function_t) ndr_print_winreg_SetKeySecurity,
4215                 False,
4216         },
4217         {
4218                 "winreg_SetValue",
4219                 sizeof(struct winreg_SetValue),
4220                 (ndr_push_flags_fn_t) ndr_push_winreg_SetValue,
4221                 (ndr_pull_flags_fn_t) ndr_pull_winreg_SetValue,
4222                 (ndr_print_function_t) ndr_print_winreg_SetValue,
4223                 False,
4224         },
4225         {
4226                 "winreg_UnLoadKey",
4227                 sizeof(struct winreg_UnLoadKey),
4228                 (ndr_push_flags_fn_t) ndr_push_winreg_UnLoadKey,
4229                 (ndr_pull_flags_fn_t) ndr_pull_winreg_UnLoadKey,
4230                 (ndr_print_function_t) ndr_print_winreg_UnLoadKey,
4231                 False,
4232         },
4233         {
4234                 "winreg_InitiateSystemShutdown",
4235                 sizeof(struct winreg_InitiateSystemShutdown),
4236                 (ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdown,
4237                 (ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdown,
4238                 (ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdown,
4239                 False,
4240         },
4241         {
4242                 "winreg_AbortSystemShutdown",
4243                 sizeof(struct winreg_AbortSystemShutdown),
4244                 (ndr_push_flags_fn_t) ndr_push_winreg_AbortSystemShutdown,
4245                 (ndr_pull_flags_fn_t) ndr_pull_winreg_AbortSystemShutdown,
4246                 (ndr_print_function_t) ndr_print_winreg_AbortSystemShutdown,
4247                 False,
4248         },
4249         {
4250                 "winreg_GetVersion",
4251                 sizeof(struct winreg_GetVersion),
4252                 (ndr_push_flags_fn_t) ndr_push_winreg_GetVersion,
4253                 (ndr_pull_flags_fn_t) ndr_pull_winreg_GetVersion,
4254                 (ndr_print_function_t) ndr_print_winreg_GetVersion,
4255                 False,
4256         },
4257         {
4258                 "winreg_OpenHKCC",
4259                 sizeof(struct winreg_OpenHKCC),
4260                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCC,
4261                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCC,
4262                 (ndr_print_function_t) ndr_print_winreg_OpenHKCC,
4263                 False,
4264         },
4265         {
4266                 "winreg_OpenHKDD",
4267                 sizeof(struct winreg_OpenHKDD),
4268                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKDD,
4269                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKDD,
4270                 (ndr_print_function_t) ndr_print_winreg_OpenHKDD,
4271                 False,
4272         },
4273         {
4274                 "winreg_QueryMultipleValues",
4275                 sizeof(struct winreg_QueryMultipleValues),
4276                 (ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues,
4277                 (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues,
4278                 (ndr_print_function_t) ndr_print_winreg_QueryMultipleValues,
4279                 False,
4280         },
4281         {
4282                 "winreg_InitiateSystemShutdownEx",
4283                 sizeof(struct winreg_InitiateSystemShutdownEx),
4284                 (ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdownEx,
4285                 (ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdownEx,
4286                 (ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdownEx,
4287                 False,
4288         },
4289         {
4290                 "winreg_SaveKeyEx",
4291                 sizeof(struct winreg_SaveKeyEx),
4292                 (ndr_push_flags_fn_t) ndr_push_winreg_SaveKeyEx,
4293                 (ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKeyEx,
4294                 (ndr_print_function_t) ndr_print_winreg_SaveKeyEx,
4295                 False,
4296         },
4297         {
4298                 "winreg_OpenHKPT",
4299                 sizeof(struct winreg_OpenHKPT),
4300                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPT,
4301                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPT,
4302                 (ndr_print_function_t) ndr_print_winreg_OpenHKPT,
4303                 False,
4304         },
4305         {
4306                 "winreg_OpenHKPN",
4307                 sizeof(struct winreg_OpenHKPN),
4308                 (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPN,
4309                 (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPN,
4310                 (ndr_print_function_t) ndr_print_winreg_OpenHKPN,
4311                 False,
4312         },
4313         {
4314                 "winreg_QueryMultipleValues2",
4315                 sizeof(struct winreg_QueryMultipleValues2),
4316                 (ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues2,
4317                 (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues2,
4318                 (ndr_print_function_t) ndr_print_winreg_QueryMultipleValues2,
4319                 False,
4320         },
4321         { NULL, 0, NULL, NULL, NULL, False }
4322 };
4323
4324 const char * const winreg_endpoint_strings[] = {
4325         "ncacn_np:[\\pipe\\winreg]",
4326         "ncacn_ip_tcp:",
4327         "ncalrpc:",
4328 };
4329
4330 const struct dcerpc_endpoint_list winreg_endpoints = {
4331         .count  = 3,
4332         .names  = winreg_endpoint_strings
4333 };
4334
4335 const char * const winreg_authservice_strings[] = {
4336         "host",
4337 };
4338
4339 const struct dcerpc_authservice_list winreg_authservices = {
4340         .count  = 3,
4341         .names  = winreg_authservice_strings
4342 };
4343
4344
4345 const struct dcerpc_interface_table dcerpc_table_winreg = {
4346         .name           = "winreg",
4347         .syntax_id      = {
4348                 {0x338cd001,0x2244,0x31f1,{0xaa,0xaa},{0x90,0x00,0x38,0x00,0x10,0x03}},
4349                 DCERPC_WINREG_VERSION
4350         },
4351         .helpstring     = DCERPC_WINREG_HELPSTRING,
4352         .num_calls      = 35,
4353         .calls          = winreg_calls,
4354         .endpoints      = &winreg_endpoints,
4355         .authservices   = &winreg_authservices
4356 };
4357