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