source3/librpc/gen_ndr/ndr_winreg.c

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