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