source3/librpc/gen_ndr/ndr_winreg.c

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