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