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