librpc/gen_ndr/ndr_winreg.c

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