librpc/gen_ndr/ndr_winreg.c

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